packages feed

singletons 2.5.1 → 2.6

raw patch · 275 files changed

+21482/−20466 lines, 275 filesdep +turtledep ~basedep ~tastydep ~th-desugarsetup-changed

Dependencies added: turtle

Dependency ranges changed: base, tasty, th-desugar

Files

CHANGES.md view
@@ -1,6 +1,163 @@ Changelog for singletons project ================================ +2.6+---+* Require GHC 8.8.+* `Sing` has switched from a data family to a type family. This has a number of+  consequences:+  * Names like `SBool`, `SMaybe`, etc. are no longer type synonyms for+    particular instantiations of `Sing` but are instead the names of the+    singleton data types themselves. In other words, previous versions of+    `singletons` would provide this:++    ```haskell+    data instance Sing :: Bool -> Type where+      SFalse :: Sing False+      STrue  :: Sing True+    type SBool = (Sing :: Bool -> Type)+    ```++    Whereas with `Sing`-as-a-type-family, `singletons` now provides this:++    ```haskell+    data SBool :: Bool -> Type where+      SFalse :: SBool False+      STrue  :: SBool True+    type instance Sing @Bool = SBool+    ```+  * The `Sing` instance for `TYPE rep` in `Data.Singletons.TypeRepTYPE` is now+    directly defined as `type instance Sing @(TYPE rep) = TypeRep`, without the+    use of an intermediate newtype as before.+  * Due to limitations in the ways that quantified constraints and type+    families can interact+    (see [this GHC issue](https://gitlab.haskell.org/ghc/ghc/issues/14860)),+    the internals of `ShowSing` has to be tweaked in order to continue to+    work with `Sing`-as-a-type-family. One notable consequence of this is+    that `Show` instances for singleton types can no longer be derived—they+    must be written by hand in order to work around+    [this GHC bug](https://gitlab.haskell.org/ghc/ghc/issues/16365).+    This is unlikely to affect you unless you define 'Show' instances for+    singleton types by hand. For more information, refer to the Haddocks for+    `ShowSing'` in `Data.Singletons.ShowSing`.+  * GHC does not permit type class instances to mention type families, which+    means that it is no longer possible to define instances that mention the+    `Sing` type constructor. For this reason, a `WrappedSing` data type (which+    is a newtype around `Sing`) was introduced so that one can hang instances+    off of it.++    This had one noticeable effect in `singletons`+    itself: there are no longer `TestEquality Sing` or `TestCoercion Sing`+    instances. Instead, `singletons` now generates a separate+    `TestEquality`/`TestCoercion` instance for every data type that singles a+    derived `Eq` instance. In addition, the `Data.Singletons.Decide` module+    now provides top-level `decideEquality`/`decideCoercion` functions which+    provide the behavior of `testEquality`/`testCoercion`, but monomorphized+    to `Sing`. Finally, `TestEquality`/`TestCoercion` instances are provided+    for `WrappedSing`.+* GHC's behavior surrounding kind inference for local definitions has changed+  in 8.8, and certain code that `singletons` generates for local definitions+  may no longer typecheck as a result. While we have taken measures to mitigate+  the issue on `singletons`' end, there still exists code that must be patched+  on the users' end in order to continue compiling. For instance, here is an+  example of code that stopped compiling with the switch to GHC 8.8:++  ```haskell+  replicateM_ :: (Applicative m) => Nat -> m a -> m ()+  replicateM_ cnt0 f =+      loop cnt0+    where+      loop cnt+          | cnt <= 0  = pure ()+          | otherwise = f *> loop (cnt - 1)+  ```++  This produces errors to the effect of:++  ```+  • Could not deduce (SNum k1) arising from a use of ‘sFromInteger’+    from the context: SApplicative m+    ...++  • Could not deduce (SOrd k1) arising from a use of ‘%<=’+    from the context: SApplicative m+    ...+  ```++  The issue is that GHC 8.8 now kind-generalizes `sLoop` (whereas it did not+  previously), explaining why the error message mentions a mysterious kind+  variable `k1` that only appeared after kind generalization. The solution is+  to give `loop` an explicit type signature like so:++  ```diff+  -replicateM_       :: (Applicative m) => Nat -> m a -> m ()+  +replicateM_       :: forall m a. (Applicative m) => Nat -> m a -> m ()+   replicateM_ cnt0 f =+       loop cnt0+     where+  +    loop :: Nat -> m ()+       loop cnt+           | cnt <= 0  = pure ()+           | otherwise = f *> loop (cnt - 1)+  ```++  This general approach should be sufficient to fix any type inference+  regressions that were introduced between GHC 8.6 and 8.8. If this isn't the+  case, please file an issue.+* Due to [GHC Trac #16133](https://ghc.haskell.org/trac/ghc/ticket/16133) being+  fixed, `singletons`-generated code now requires explicitly enabling the+  `TypeApplications` extension. (The generated code was always using+  `TypeApplications` under the hood, but it's only now that GHC is detecting+  it.)+* `Data.Singletons` now defines a family of `SingI` instances for `TyCon1`+  through `TyCon8`:++  ```haskell+  instance (forall a.    SingI a           => SingI (f a),   ...) => SingI (TyCon1 f)+  instance (forall a b. (SingI a, SingI b) => SingI (f a b), ...) => SingI (TyCon2 f)+  ...+  ```++  As a result, `singletons` no longer generates instances for `SingI` instances+  for applications of `TyCon{N}` to particular type constructors, as they have+  been superseded by the instances above.+* Changes to `Data.Singletons.Sigma`:+  * `SSigma`, the singleton type for `Sigma`, is now defined.+  * New functions `fstSigma`, `sndSigma`, `FstSigma`, `SndSigma`, `currySigma`,+    and `uncurrySigma` have been added. A `Show` instance for `Sigma` has also+    been added.+  * `projSigma1` has been redefined to use continuation-passing style to more+    closely resemble its cousin `projSigma2`. The new type signature of+    `projSigma1` is:++    ```hs+    projSigma1 :: (forall (fst :: s). Sing fst -> r) -> Sigma s t -> r+    ```++    The old type signature of `projSigma1` can be found in the `fstSigma`+    function.+  * `Σ` has been redefined such that it is now a partial application of+    `Sigma`, like so:++    ```haskell+    type Σ = Sigma+    ```++    One benefit of this change is that one no longer needs defunctionalization+    symbols in order to partially apply `Σ`. As a result, `ΣSym0`, `ΣSym1`,+    and `ΣSym2` have been removed.+* In line with corresponding changes in `base-4.13`, the `Fail`/`sFail` methods+  of `{P,S}Monad` have been removed in favor of new `{P,S}MonadFail` classes+  introduced in the `Data.Singletons.Prelude.Monad.Fail` module. These classes+  are also re-exported from `Data.Singletons.Prelude`.+* Fix a bug where expressions with explicit signatures involving function types+  would fail to single.+* The infix names `(.)` and `(!)` are no longer mapped to `(:.)` and `(:!)`,+  as GHC 8.8 learned to parse them at the type level.+* The `Enum` instance for `SomeSing` now uses more efficient implementations of+  `enumFromTo` and `enumFromThenTo` that no longer require a `SingKind`+  constraint.+ 2.5.1 ----- * `ShowSing` is now a type class (with a single instance) instead of a type
README.md view
@@ -1,5 +1,5 @@-singletons 2.5.1-================+singletons 2.6+==============  [![Hackage](https://img.shields.io/hackage/v/singletons.svg)](http://hackage.haskell.org/package/singletons) [![Build Status](https://travis-ci.org/goldfirere/singletons.svg?branch=master)](https://travis-ci.org/goldfirere/singletons)@@ -40,7 +40,7 @@ Compatibility ------------- -The singletons library requires GHC 8.6.1 or greater. Any code that uses the+The singletons library requires GHC 8.8.1 or greater. Any code that uses the singleton generation primitives needs to enable a long list of GHC extensions. This list includes, but is not necessarily limited to, the following:@@ -58,8 +58,8 @@ * `PolyKinds` * `RankNTypes` * `ScopedTypeVariables`-* `StandaloneDeriving` * `TemplateHaskell`+* `TypeApplications` * `TypeFamilies` * `TypeOperators` * `UndecidableInstances`@@ -151,10 +151,10 @@ definitions. Many of the definitions were developed in tandem with Iavor Diatchki.  ```haskell-data family Sing (a :: k)+type family Sing :: k -> Type ``` -The data family of singleton types. A new instance of this data family is+The type family of singleton types. A new instance of this type family is generated for every new singleton type.  ```haskell@@ -221,9 +221,10 @@ while propositional equality has the advantage that GHC can use the equality of types during type inference. -Instances of both `SEq` and `SDecide` are generated when `singletons` is called-on a datatype that has `deriving Eq`. You can also generate these instances-directly through functions exported from `Data.Singletons.TH`.+Instances of `SEq`, `SDecide`, `TestEquality`, and `TestCoercion` are generated+when `singletons` is called on a datatype that has `deriving Eq`. You can also+generate these instances directly through functions exported from+`Data.Singletons.TH`.   `Show` classes@@ -534,27 +535,7 @@    All tuples (including the 0-tuple, unit) are treated similarly.  -6. original value: `(.)`--   promoted type\*: `(:.)`--   singleton value: `(%.)`--   symbols: `(.@#@$)`, `(.@#@$$)`, `(.@#@$$$)`--   The promoted type is special because GHC can't parse a type named `(.)`.--7. original value: `(!)`--   promoted type\*: `(:!)`--   singleton value: `(%!)`--   symbols: `(!@#@$)`, `(!@#@$$)`, `(!@#@$$$)`--   The promoted type is special because GHC can't parse a type named `(!)`.--8. original value: `___foo`+6. original value: `___foo`     promoted type\*: `US___foo` ("`US`" stands for "underscore") @@ -711,8 +692,8 @@  The built-in Haskell promotion mechanism does not yet have a full story around the kind `*` (the kind of types that have values). Ideally, promoting some form-of `TypeRep` would yield `*`, but the implementation of TypeRep would have to be-updated for this to really work out. In the meantime, users who wish to+of `TypeRep` would yield `*`, but the implementation of `TypeRep` would have to+be updated for this to really work out. In the meantime, users who wish to experiment with this feature have two options:  1) The module `Data.Singletons.TypeRepTYPE` has all the definitions possible for@@ -720,14 +701,12 @@ The singleton associated with `TypeRep` has one constructor:      ```haskell-    newtype instance Sing :: forall (rep :: RuntimeRep). TYPE rep -> Type where-      STypeRep :: forall (rep :: RuntimeRep) (a :: TYPE rep). TypeRep a -> Sing a+    type instance Sing @(TYPE rep) = TypeRep     ``` -   (Recall that `type * = TYPE LiftedRep`.) Thus, a `TypeRep` is stored in the-singleton constructor. However, any datatypes that store `TypeRep`s will not-generally work as expected; the built-in promotion mechanism will not promote-`TypeRep` to `*`.+    (Recall that `type * = TYPE LiftedRep`.) Note that any datatypes that store+`TypeRep`s will not generally work as expected; the built-in promotion+mechanism will not promote `TypeRep` to `*`.  2) The module `Data.Singletons.CustomStar` allows the programmer to define a subset of types with which to work. See the Haddock documentation for the function
Setup.hs view
@@ -47,7 +47,7 @@                 | otherwise           = distPref       -- Package DBs       dbStack = withPackageDB lbi ++ [ SpecificPackageDB $ distPref' </> "package.conf.inplace" ]-      dbFlags = "-hide-all-packages" : packageDbArgsDb dbStack+      dbFlags = "-hide-all-packages" : "-package-env=-" : packageDbArgsDb dbStack        ghc = case lookupProgram ghcProgram (withPrograms lbi) of               Just fp -> locationPath $ programLocation fp
singletons.cabal view
@@ -1,5 +1,5 @@ name:           singletons-version:        2.5.1+version:        2.6                 -- Remember to bump version in the Makefile as well cabal-version:  >= 1.10 synopsis:       A framework for generating singleton types@@ -9,17 +9,17 @@ maintainer:     Ryan Scott <ryan.gl.scott@gmail.com> bug-reports:    https://github.com/goldfirere/singletons/issues stability:      experimental-tested-with:    GHC == 8.6.2+tested-with:    GHC == 8.8.1 extra-source-files: README.md, CHANGES.md,                     tests/compile-and-dump/buildGoldenFiles.awk,                     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/*.ghc86.template,-                    tests/compile-and-dump/InsertionSort/*.ghc86.template,-                    tests/compile-and-dump/Promote/*.ghc86.template,-                    tests/compile-and-dump/Singletons/*.ghc86.template+                    tests/compile-and-dump/GradingClient/*.ghc88.template,+                    tests/compile-and-dump/InsertionSort/*.ghc88.template,+                    tests/compile-and-dump/Promote/*.ghc88.template,+                    tests/compile-and-dump/Singletons/*.ghc88.template license:        BSD3 license-file:   LICENSE build-type:     Custom@@ -38,7 +38,7 @@ source-repository this   type:     git   location: https://github.com/goldfirere/singletons.git-  tag:      v2.5.1+  tag:      v2.6  source-repository head   type:     git@@ -47,19 +47,19 @@  custom-setup   setup-depends:-    base      >= 4.12 && < 4.13,-    Cabal     >= 2.3 && < 2.5,+    base      >= 4.13 && < 4.14,+    Cabal     >= 2.5 && < 3.1,     directory >= 1,     filepath  >= 1.3  library   hs-source-dirs:     src-  build-depends:      base >= 4.12 && < 4.13,+  build-depends:      base >= 4.13 && < 4.14,                       mtl >= 2.2.1,                       ghc-boot-th,                       template-haskell,                       containers >= 0.5,-                      th-desugar >= 1.9 && < 1.10,+                      th-desugar >= 1.10 && < 1.11,                       pretty,                       syb >= 0.4,                       text >= 1.2,@@ -91,6 +91,7 @@                       Data.Singletons.Prelude.List.NonEmpty                       Data.Singletons.Prelude.Maybe                       Data.Singletons.Prelude.Monad+                      Data.Singletons.Prelude.Monad.Fail                       Data.Singletons.Prelude.Monad.Zip                       Data.Singletons.Prelude.Monoid                       Data.Singletons.Prelude.Num@@ -139,21 +140,23 @@                       Data.Singletons.TypeLits.Internal                       Data.Singletons.Syntax -  ghc-options:        -Wall -Wno-redundant-constraints+  ghc-options:        -Wall -Wcompat -Wno-redundant-constraints  test-suite singletons-test-suite   type:               exitcode-stdio-1.0   hs-source-dirs:     tests-  ghc-options:        -Wall+  ghc-options:        -Wall -Wcompat -threaded -with-rtsopts=-maxN16   default-language:   Haskell2010   main-is:            SingletonsTestSuite.hs   other-modules:      ByHand                       ByHand2                       SingletonsTestSuiteUtils -  build-depends:      base >= 4.12 && < 4.13,+  build-depends:      base >= 4.13 && < 4.14,                       filepath >= 1.3,                       process >= 1.1,+                      turtle >= 1.5,+                      text >= 1.2,                       singletons,-                      tasty >= 0.6,+                      tasty >= 1.2,                       tasty-golden >= 2.2
src/Data/Singletons.hs view
@@ -1,12 +1,16 @@ {-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE ExplicitNamespaces #-}+{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE MagicHash #-} {-# LANGUAGE PatternSynonyms #-} {-# LANGUAGE PolyKinds #-}+{-# LANGUAGE QuantifiedConstraints #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -35,7 +39,7 @@ module Data.Singletons (   -- * Main singleton definitions -  Sing(SLambda, applySing), (@@),+  Sing, SLambda(..), (@@),    SingI(..), SingKind(..), @@ -49,6 +53,10 @@   singByProxy#,   withSing, singThat, +  -- ** @WrappedSing@+  WrappedSing(..), SWrappedSing(..), UnwrapSing,+  -- $SingletonsOfSingletons+   -- ** Defunctionalization   TyFun, type (~>),   TyCon1, TyCon2, TyCon3, TyCon4, TyCon5, TyCon6, TyCon7, TyCon8,@@ -85,6 +93,7 @@ import Data.Singletons.Internal import Data.Singletons.Prelude.Enum import Data.Singletons.Prelude.Eq+import Data.Singletons.Prelude.Instances import Data.Singletons.Prelude.IsString import Data.Singletons.Prelude.Monoid import Data.Singletons.Prelude.Num@@ -92,10 +101,24 @@ import Data.Singletons.Prelude.Semigroup import Data.Singletons.Promote import Data.Singletons.ShowSing+import Data.Singletons.Single (singITyConInstances) import Data.String import qualified Data.Text as T (pack)  ----------------------------------------------------------------------+---- SingI TyCon{N} instances ----------------------------------------+----------------------------------------------------------------------++{-+Generates SingI instances for TyCon1 through TyCon8:++  instance (forall a.    SingI a           => SingI (f a),   ...) => SingI (TyCon1 f)+  instance (forall a b. (SingI a, SingI b) => SingI (f a b), ...) => SingI (TyCon2 f)+  ...+-}+$(singITyConInstances [1..8])++---------------------------------------------------------------------- ---- SomeSing instances ---------------------------------------------- ---------------------------------------------------------------------- @@ -114,16 +137,22 @@   minBound = SomeSing sMinBound   maxBound = SomeSing sMaxBound -instance (SEnum k, SingKind k) => Enum (SomeSing k) where+instance SEnum k => Enum (SomeSing k) where   succ (SomeSing a) = SomeSing (sSucc a)   pred (SomeSing a) = SomeSing (sPred a)   toEnum n = withSomeSing (fromIntegral n) (SomeSing . sToEnum)   fromEnum (SomeSing a) = fromIntegral (fromSing (sFromEnum a))   enumFromTo (SomeSing from) (SomeSing to) =-    map toSing (fromSing (sEnumFromTo from to))+    listFromSingShallow (sEnumFromTo from to)   enumFromThenTo (SomeSing from) (SomeSing then_) (SomeSing to) =-    map toSing (fromSing (sEnumFromThenTo from then_ to))+    listFromSingShallow (sEnumFromThenTo from then_ to) +-- Like the 'fromSing' implementation for lists, but bottoms out at+-- 'SomeSing' instead of recursively invoking 'fromSing'.+listFromSingShallow :: SList (x :: [a]) -> [SomeSing a]+listFromSingShallow SNil         = []+listFromSingShallow (SCons x xs) = SomeSing x : listFromSingShallow xs+ instance SNum k => Num (SomeSing k) where   SomeSing a + SomeSing b = SomeSing (a %+ b)   SomeSing a - SomeSing b = SomeSing (a %- b)@@ -133,7 +162,10 @@   signum (SomeSing a) = SomeSing (sSignum a)   fromInteger n = withSomeSing (fromIntegral n) (SomeSing . sFromInteger) -deriving instance ShowSing k => Show (SomeSing k)+instance ShowSing k => Show (SomeSing k) where+  showsPrec p (SomeSing (s :: Sing a)) =+    showParen (p > 10) $ showString "SomeSing " . showsPrec 11 s+      :: ShowSing' a => ShowS  instance SSemigroup k => Semigroup (SomeSing k) where   SomeSing a <> SomeSing b = SomeSing (a %<> b)@@ -149,7 +181,76 @@ ----------------------------------------------------------------------  $(genDefunSymbols [''Demote, ''SameKind, ''KindOf, ''(~>), ''Apply, ''(@@)])--- SingFunction1 et al. are not defunctionalizable at the moment due to #198+-- WrapSing, UnwrapSing, and SingFunction1 et al. are not defunctionalizable+-- at the moment due to Trac #9269++{- $SingletonsOfSingletons++Aside from being a data type to hang instances off of, 'WrappedSing' has+another purpose as a general-purpose mechanism for allowing one to write+code that uses singletons of other singletons. For instance, suppose you+had the following data type:++@+data T :: Type -> Type where+  MkT :: forall a (x :: a). 'Sing' x -> F a -> T a+@++A naïve attempt at defining a singleton for @T@ would look something like+this:++@+data ST :: forall a. T a -> Type where+  SMkT :: forall a (x :: a) (sx :: 'Sing' x) (f :: F a).+          'Sing' sx -> 'Sing' f -> ST (MkT sx f)+@++But there is a problem here: what exactly /is/ @'Sing' sx@? If @x@ were 'True',+for instance, then @sx@ would be 'STrue', but it's not clear what+@'Sing' 'STrue'@ should be. One could define @SSBool@ to be the singleton of+'SBool's, but in order to be thorough, one would have to generate a singleton+for /every/ singleton type out there. Plus, it's not clear when to stop. Should+we also generate @SSSBool@, @SSSSBool@, etc.?++Instead, 'WrappedSing' and its singleton 'SWrappedSing' provide a way to talk+about singletons of other arbitrary singletons without the need to generate a+bazillion instances. For reference, here is the definition of 'SWrappedSing':++@+newtype 'SWrappedSing' :: forall k (a :: k). 'WrappedSing' a -> Type where+  'SWrapSing' :: forall k (a :: k) (ws :: 'WrappedSing' a).+                 { 'sUnwrapSing' :: 'Sing' a } -> 'SWrappedSing' ws+type instance 'Sing' \@('WrappedSing' a) = 'SWrappedSing'+@++'SWrappedSing' is a bit of an unusual singleton in that its field is a+singleton for @'Sing' \@k@, not @'WrappedSing' \@k@. But that's exactly the+point—a singleton of a singleton contains as much type information as the+underlying singleton itself, so we can get away with just @'Sing' \@k@.++As an example of this in action, here is how you would define the singleton+for the earlier @T@ type:++@+data ST :: forall a. T a -> Type where+  SMkT :: forall a (x :: a) (sx :: 'Sing' x) (f :: F a).+          'Sing' ('WrapSing' sx) -> 'Sing' f -> ST (MkT sx f)+@++With this technique, we won't need anything like @SSBool@ in order to+instantiate @x@ with 'True'. Instead, the field of type+@'Sing' ('WrapSing' sx)@ will simply be a newtype around 'SBool'. In general,+you'll need /n/ layers of 'WrapSing' if you wish to single a singleton /n/+times.++Note that this is not the only possible way to define a singleton for @T@.+An alternative approach that does not make use of singletons-of-singletons is+discussed at some length+<https://github.com/goldfirere/singletons/issues/366#issuecomment-489469086 here>.+Due to the technical limitations of this approach, however, we do not use it+in @singletons@ at the moment, instead favoring the+slightly-clunkier-but-more-reliable 'WrappedSing' approach.+-}  {- $SLambdaPatternSynonyms
src/Data/Singletons/CustomStar.hs view
@@ -60,10 +60,11 @@ -- and its singleton. However, because @Rep@ is promoted to @*@, the singleton -- is perhaps slightly unexpected: ----- > data instance Sing (a :: *) where+-- > data SRep (a :: *) where -- >   SNat :: Sing Nat -- >   SBool :: Sing Bool -- >   SMaybe :: Sing a -> Sing (Maybe a)+-- > type instance Sing = SRep -- -- The unexpected part is that @Nat@, @Bool@, and @Maybe@ above are the real @Nat@, -- @Bool@, and @Maybe@, not just promoted data constructors.@@ -76,7 +77,7 @@   kinds <- mapM getKind names   ctors <- zipWithM (mkCtor True) names kinds   let repDecl = DDataD Data [] repName [] (Just (DConT typeKindName)) ctors-                         [DDerivClause Nothing (map DConPr [''Eq, ''Ord, ''Read, ''Show])]+                         [DDerivClause Nothing (map DConT [''Eq, ''Ord, ''Read, ''Show])]   fakeCtors <- zipWithM (mkCtor False) names kinds   let dataDecl = DataDecl repName [] fakeCtors   -- Why do we need withLocalDeclarations here? It's because we end up@@ -86,10 +87,10 @@   withLocalDeclarations (decToTH repDecl) $ do     -- We opt to infer the constraints for the Eq instance here so that when it's     -- promoted, Rep will be promoted to Type.-    dataDeclEqCxt <- inferConstraints (DConPr ''Eq) (DConT repName) fakeCtors-    let dataDeclEqInst = DerivedDecl (Just dataDeclEqCxt) (DConT repName) dataDecl+    dataDeclEqCxt <- inferConstraints (DConT ''Eq) (DConT repName) fakeCtors+    let dataDeclEqInst = DerivedDecl (Just dataDeclEqCxt) (DConT repName) repName dataDecl     ordInst  <- mkOrdInstance Nothing (DConT repName) dataDecl-    showInst <- mkShowInstance Nothing (DConT repName) dataDecl+    showInst <- mkShowInstance ForPromotion Nothing (DConT repName) dataDecl     (pInsts, promDecls) <- promoteM [] $ do promoteDataDec dataDecl                                             promoteDerivedEqDec dataDeclEqInst                                             traverse (promoteInstanceDec mempty)@@ -131,21 +132,24 @@               noBang = Bang NoSourceUnpackedness NoSourceStrictness          -- demote a kind back to a type, accumulating any unbound parameters-        kindToType :: DsMonad q => [DType] -> DKind -> QWithAux [Name] q DType+        kindToType :: DsMonad q => [DTypeArg] -> DKind -> QWithAux [Name] q DType         kindToType _    (DForallT _ _ _) = fail "Explicit forall encountered in kind"         kindToType args (DAppT f a) = do           a' <- kindToType [] a-          kindToType (a' : args) f+          kindToType (DTANormal a' : args) f+        kindToType args (DAppKindT f a) = do+          a' <- kindToType [] a+          kindToType (DTyArg a' : args) f         kindToType args (DSigT t k) = do           t' <- kindToType [] t           k' <- kindToType [] k-          return $ DSigT t' k' `foldType` args+          return $ DSigT t' k' `applyDType` args         kindToType args (DVarT n) = do           addElement n-          return $ DVarT n `foldType` args-        kindToType args (DConT n)    = return $ DConT name    `foldType` args+          return $ DVarT n `applyDType` args+        kindToType args (DConT n)    = return $ DConT name `applyDType` args           where name | isTypeKindName n = repName                      | otherwise        = n-        kindToType args DArrowT      = return $ DArrowT       `foldType` args-        kindToType args k@(DLitT {}) = return $ k             `foldType` args-        kindToType args DWildCardT   = return $ DWildCardT    `foldType` args+        kindToType args DArrowT      = return $ DArrowT    `applyDType` args+        kindToType args k@(DLitT {}) = return $ k          `applyDType` args+        kindToType args DWildCardT   = return $ DWildCardT `applyDType` args
src/Data/Singletons/Decide.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE RankNTypes, PolyKinds, DataKinds, TypeOperators,-             TypeFamilies, FlexibleContexts, UndecidableInstances, GADTs #-}+             TypeFamilies, FlexibleContexts, UndecidableInstances,+             GADTs, TypeApplications #-} {-# OPTIONS_GHC -Wno-orphans #-}  -----------------------------------------------------------------------------@@ -20,10 +21,10 @@   SDecide(..),    -- * Supporting definitions-  (:~:)(..), Void, Refuted, Decision(..)+  (:~:)(..), Void, Refuted, Decision(..),+  decideEquality, decideCoercion   ) where -import Data.Kind (Type) import Data.Singletons.Internal import Data.Type.Coercion import Data.Type.Equality@@ -51,14 +52,26 @@   (%~) :: forall (a :: k) (b :: k). Sing a -> Sing b -> Decision (a :~: b)   infix 4 %~ -instance SDecide k => TestEquality (Sing :: k -> Type) where-  testEquality a b =-    case a %~ b of-      Proved Refl -> Just Refl-      Disproved _ -> Nothing+-- | A suitable default implementation for 'testEquality' that leverages+-- 'SDecide'.+decideEquality :: forall k (a :: k) (b :: k). SDecide k+               => Sing a -> Sing b -> Maybe (a :~: b)+decideEquality a b =+  case a %~ b of+    Proved Refl -> Just Refl+    Disproved _ -> Nothing -instance SDecide k => TestCoercion (Sing :: k -> Type) where-  testCoercion a b =-    case a %~ b of-      Proved Refl -> Just Coercion-      Disproved _ -> Nothing+instance SDecide k => TestEquality (WrappedSing @k) where+  testEquality (WrapSing s1) (WrapSing s2) = decideEquality s1 s2++-- | A suitable default implementation for 'testCoercion' that leverages+-- 'SDecide'.+decideCoercion :: forall k (a :: k) (b :: k). SDecide k+               => Sing a -> Sing b -> Maybe (Coercion a b)+decideCoercion a b =+  case a %~ b of+    Proved Refl -> Just Coercion+    Disproved _ -> Nothing++instance SDecide k => TestCoercion (WrappedSing @k) where+  testCoercion (WrapSing s1) (WrapSing s2) = decideCoercion s1 s2
src/Data/Singletons/Deriving/Bounded.hs view
@@ -50,7 +50,7 @@           in (minEqnRHS, maxEqnRHS)        mk_rhs rhs = UFunction [DClause [] rhs]-  constraints <- inferConstraintsDef mb_ctxt (DConPr boundedName) ty cons+  constraints <- inferConstraintsDef mb_ctxt (DConT boundedName) ty cons   return $ InstDecl { id_cxt = constraints                     , id_name = boundedName                     , id_arg_tys = [ty]
src/Data/Singletons/Deriving/Enum.hs view
@@ -33,15 +33,15 @@               non_vanilla || not (null $ tysOfConFields f)) cons) $     fail ("Can't derive Enum instance for " ++ pprint (typeToTH ty) ++ ".")   n <- qNewName "n"-  let to_enum = UFunction [DClause [DVarPa n] (to_enum_rhs cons [0..])]+  let to_enum = UFunction [DClause [DVarP n] (to_enum_rhs cons [0..])]       to_enum_rhs [] _ = DVarE errorName `DAppE` DLitE (StringL "toEnum: bad argument")       to_enum_rhs (DCon _ _ name _ _ : rest) (num:nums) =         DCaseE (DVarE equalsName `DAppE` DVarE n `DAppE` DLitE (IntegerL num))-          [ DMatch (DConPa trueName []) (DConE name)-          , DMatch (DConPa falseName []) (to_enum_rhs rest nums) ]+          [ DMatch (DConP trueName []) (DConE name)+          , DMatch (DConP falseName []) (to_enum_rhs rest nums) ]       to_enum_rhs _ _ = error "Internal error: exhausted infinite list in to_enum_rhs" -      from_enum = UFunction (zipWith (\i con -> DClause [DConPa (extractName con) []]+      from_enum = UFunction (zipWith (\i con -> DClause [DConP (extractName con) []]                                                         (DLitE (IntegerL i)))                                      [0..] cons)   return (InstDecl { id_cxt     = fromMaybe [] mb_ctxt
src/Data/Singletons/Deriving/Foldable.hs view
@@ -69,17 +69,17 @@       mk_foldMap_clause :: DCon -> q DClause       mk_foldMap_clause con = do         parts <- foldDataConArgs ft_foldMap con-        clause_for_foldMap [DVarPa f] con =<< sequence parts+        clause_for_foldMap [DVarP f] con =<< sequence parts        mk_foldr_clause :: DCon -> q DClause       mk_foldr_clause con = do         parts <- foldDataConArgs ft_foldr con-        clause_for_foldr [DVarPa f, DVarPa z] con =<< sequence parts+        clause_for_foldr [DVarP f, DVarP z] con =<< sequence parts        mk_foldMap :: q [DClause]       mk_foldMap =         case cons of-          [] -> pure [DClause [DWildPa, DWildPa] (DVarE memptyName)]+          [] -> pure [DClause [DWildP, DWildP] (DVarE memptyName)]           _  -> traverse mk_foldMap_clause cons        mk_foldr :: q [DClause]@@ -91,7 +91,7 @@               : case cons of                   [] -> []                   _  -> [(foldrName, UFunction foldr_clauses)]-  constraints <- inferConstraintsDef mb_ctxt (DConPr foldableName) ty cons+  constraints <- inferConstraintsDef mb_ctxt (DConT foldableName) ty cons   return $ InstDecl { id_cxt = constraints                     , id_name = foldableName                     , id_arg_tys = [ty]
src/Data/Singletons/Deriving/Functor.hs view
@@ -61,28 +61,28 @@       mk_fmap_clause :: DCon -> q DClause       mk_fmap_clause con = do         parts <- foldDataConArgs ft_fmap con-        clause_for_con [DVarPa f] con =<< sequence parts+        clause_for_con [DVarP f] con =<< sequence parts        mk_replace_clause :: DCon -> q DClause       mk_replace_clause con = do         parts <- foldDataConArgs ft_replace con-        clause_for_con [DVarPa z] con =<< traverse (fmap replace) parts+        clause_for_con [DVarP z] con =<< traverse (fmap replace) parts        mk_fmap :: q [DClause]       mk_fmap = case cons of                   [] -> do v <- newUniqueName "v"-                           pure [DClause [DWildPa, DVarPa v] (DCaseE (DVarE v) [])]+                           pure [DClause [DWildP, DVarP v] (DCaseE (DVarE v) [])]                   _  -> traverse mk_fmap_clause cons        mk_replace :: q [DClause]       mk_replace = case cons of                      [] -> do v <- newUniqueName "v"-                              pure [DClause [DWildPa, DVarPa v] (DCaseE (DVarE v) [])]+                              pure [DClause [DWildP, DVarP v] (DCaseE (DVarE v) [])]                      _  -> traverse mk_replace_clause cons    fmap_clauses    <- mk_fmap   replace_clauses <- mk_replace-  constraints <- inferConstraintsDef mb_ctxt (DConPr functorName) ty cons+  constraints <- inferConstraintsDef mb_ctxt (DConT functorName) ty cons   return $ InstDecl { id_cxt = constraints                     , id_name = functorName                     , id_arg_tys = [ty]
src/Data/Singletons/Deriving/Infer.hs view
@@ -20,8 +20,6 @@ import Data.Singletons.Deriving.Util import Data.Singletons.Util import Data.List-import Data.List.NonEmpty (NonEmpty(..))-import Data.Generics.Twins  -- @inferConstraints cls inst_ty cons@ infers the instance context for a -- derived type class instance of @cls@ for @inst_ty@, using the constructors@@ -63,7 +61,7 @@ -- For more information on what this means, refer to the documentation for -- infer_ct below. inferConstraints :: forall q. DsMonad q => DPred -> DType -> [DCon] -> q DCxt-inferConstraints pr inst_ty = fmap (nubBy geq) . concatMapM infer_ct+inferConstraints pr inst_ty = fmap nub . concatMapM infer_ct   where     -- A thorny situation arises when attempting to infer an instance context     -- for a GADT. Consider the following example:@@ -128,7 +126,7 @@                       Just subst -> traverse (substTy subst) field_tys       if is_functor_like          then mk_functor_like_constraints field_tys' res_ty'-         else pure $ map (pr `DAppPr`) field_tys'+         else pure $ map (pr `DAppT`) field_tys'      -- If we derive a Functor-like class, e.g.,     --@@ -142,15 +140,15 @@       -- This function is partial. But that's OK, because       -- functorLikeValidityChecks ensures that this is total by the time       -- we invoke this.-      let _ :| res_ty_args     = unfoldType res_ty-          (_, last_res_ty_arg) = snocView res_ty_args+      let (_, res_ty_args)     = unfoldDType res_ty+          (_, last_res_ty_arg) = snocView $ filterDTANormals res_ty_args           Just last_tv         = getDVarTName_maybe last_res_ty_arg       deep_subtypes <- concatMapM (deepSubtypesContaining last_tv) fields-      pure $ map (pr `DAppPr`) deep_subtypes+      pure $ map (pr `DAppT`) deep_subtypes      is_functor_like :: Bool     is_functor_like-      | DConT pr_class_name :| _ <- unfoldType (predToType pr)+      | (DConT pr_class_name, _) <- unfoldDType pr       = isFunctorLikeClassName pr_class_name       | otherwise       = False
src/Data/Singletons/Deriving/Ord.hs view
@@ -24,7 +24,7 @@ -- | Make a *non-singleton* Ord instance mkOrdInstance :: DsMonad q => DerivDesc q mkOrdInstance mb_ctxt ty (DataDecl _ _ cons) = do-  constraints <- inferConstraintsDef mb_ctxt (DConPr ordName) ty cons+  constraints <- inferConstraintsDef mb_ctxt (DConT ordName) ty cons   compare_eq_clauses <- mapM mk_equal_clause cons   let compare_noneq_clauses = map (uncurry mk_nonequal_clause)                                   [ (con1, con2)@@ -45,8 +45,8 @@   let tys = tysOfConFields fields   a_names <- mapM (const $ newUniqueName "a") tys   b_names <- mapM (const $ newUniqueName "b") tys-  let pat1 = DConPa name (map DVarPa a_names)-      pat2 = DConPa name (map DVarPa b_names)+  let pat1 = DConP name (map DVarP a_names)+      pat2 = DConP name (map DVarP b_names)   return $ DClause [pat1, pat2] (DVarE foldlName `DAppE`                                  DVarE thenCmpName `DAppE`                                  DConE cmpEQName `DAppE`@@ -63,9 +63,9 @@                           EQ -> DConE cmpEQName                           GT -> DConE cmpGTName)   where-    pat1 = DConPa name1 (map (const DWildPa) (tysOfConFields fields1))-    pat2 = DConPa name2 (map (const DWildPa) (tysOfConFields fields2))+    pat1 = DConP name1 (map (const DWildP) (tysOfConFields fields1))+    pat2 = DConP name2 (map (const DWildP) (tysOfConFields fields2))  -- A variant of mk_equal_clause tailored to empty datatypes mk_empty_clause :: DClause-mk_empty_clause = DClause [DWildPa, DWildPa] (DConE cmpEQName)+mk_empty_clause = DClause [DWildP, DWildP] (DConE cmpEQName)
src/Data/Singletons/Deriving/Show.hs view
@@ -13,6 +13,7 @@ {-# LANGUAGE ScopedTypeVariables #-} module Data.Singletons.Deriving.Show (     mkShowInstance+  , ShowMode(..)   , mkShowSingContext   ) where @@ -27,60 +28,84 @@ import GHC.Lexeme (startsConSym, startsVarSym) import GHC.Show (appPrec, appPrec1) -mkShowInstance :: DsMonad q => DerivDesc q-mkShowInstance mb_ctxt ty (DataDecl _ _ cons) = do-  clauses <- mk_showsPrec cons-  constraints <- inferConstraintsDef mb_ctxt (DConPr showName) ty cons+mkShowInstance :: DsMonad q => ShowMode -> DerivDesc q+mkShowInstance mode mb_ctxt ty (DataDecl _ _ cons) = do+  clauses <- mk_showsPrec mode cons+  constraints <- inferConstraintsDef (fmap (mkShowSingContext mode) mb_ctxt)+                                     (DConT (mk_Show_name mode))+                                     ty cons+  ty' <- mk_Show_inst_ty mode ty   return $ InstDecl { id_cxt = constraints                     , id_name = showName-                    , id_arg_tys = [ty]+                    , id_arg_tys = [ty']                     , id_sigs  = mempty                     , id_meths = [ (showsPrecName, UFunction clauses) ] } -mk_showsPrec :: DsMonad q => [DCon] -> q [DClause]-mk_showsPrec cons = do+mk_showsPrec :: DsMonad q => ShowMode -> [DCon] -> q [DClause]+mk_showsPrec mode cons = do     p <- newUniqueName "p" -- The precedence argument (not always used)     if null cons        then do v <- newUniqueName "v"-               pure [DClause [DWildPa, DVarPa v] (DCaseE (DVarE v) [])]-       else mapM (mk_showsPrec_clause p) cons+               pure [DClause [DWildP, DVarP v] (DCaseE (DVarE v) [])]+       else mapM (mk_showsPrec_clause mode p) cons  mk_showsPrec_clause :: forall q. DsMonad q-                    => Name -> DCon+                    => ShowMode -> Name -> DCon                     -> q DClause-mk_showsPrec_clause p (DCon _ _ con_name con_fields _) = go con_fields+mk_showsPrec_clause mode p (DCon _ _ con_name con_fields _) = go con_fields   where+    con_name' :: Name+    con_name' = case mode of+                  ForPromotion  -> con_name+                  ForShowSing{} -> singDataConName con_name+     go :: DConFields -> q DClause      -- No fields: print just the constructor name, with no parentheses     go (DNormalC _ []) = return $-      DClause [DWildPa, DConPa con_name []] $-        DVarE showStringName `DAppE` dStringE (parenInfixConName con_name "")+      DClause [DWildP, DConP con_name' []] $+        DVarE showStringName `DAppE` dStringE (parenInfixConName con_name' "")      -- Infix constructors have special Show treatment.-    go (DNormalC True [_, _]) = do-      argL <- newUniqueName "argL"-      argR <- newUniqueName "argR"-      fi <- fromMaybe defaultFixity <$> reifyFixityWithLocals con_name-      let con_prec = case fi of Fixity prec _ -> prec-          op_name  = nameBase con_name-          infixOpE = DAppE (DVarE showStringName) . dStringE $-                       if isInfixDataCon op_name-                          then " "  ++ op_name ++ " "-                          -- Make sure to handle infix data constructors-                          -- like (Int `Foo` Int)-                          else " `" ++ op_name ++ "` "-      return $ DClause [DVarPa p, DConPa con_name [DVarPa argL, DVarPa argR]] $-        (DVarE showParenName `DAppE` (DVarE gtName `DAppE` DVarE p-                                                   `DAppE` dIntegerE con_prec))-          `DAppE` (DVarE composeName-                     `DAppE` showsPrecE (con_prec + 1) argL-                     `DAppE` (DVarE composeName-                                `DAppE` infixOpE-                                `DAppE` showsPrecE (con_prec + 1) argR))+    go (DNormalC True tys@[_, _])+        -- Although the (:) constructor is infix, its singled counterpart SCons+        -- is not, which matters if we're deriving a ShowSing instance.+        -- Unless we remove this special case (see #234), we will simply+        -- shunt it along as if we were dealing with a prefix constructor.+      | ForShowSing{} <- mode+      , con_name == consName+      = go (DNormalC False tys) +      | otherwise+      = do argL   <- newUniqueName "argL"+           argR   <- newUniqueName "argR"+           argTyL <- newUniqueName "argTyL"+           argTyR <- newUniqueName "argTyR"+           fi <- fromMaybe defaultFixity <$> reifyFixityWithLocals con_name'+           let con_prec = case fi of Fixity prec _ -> prec+               op_name  = nameBase con_name'+               infixOpE = DAppE (DVarE showStringName) . dStringE $+                            if isInfixDataCon op_name+                               then " "  ++ op_name ++ " "+                               -- Make sure to handle infix data constructors+                               -- like (Int `Foo` Int)+                               else " `" ++ op_name ++ "` "+           return $ DClause [ DVarP p+                            , DConP con_name' $+                              zipWith (mk_Show_arg_pat mode) [argL, argR] [argTyL, argTyR]+                            ] $+             mk_Show_rhs_sig mode [argTyL, argTyR] $+             (DVarE showParenName `DAppE` (DVarE gtName `DAppE` DVarE p+                                                        `DAppE` dIntegerE con_prec))+               `DAppE` (DVarE composeName+                          `DAppE` showsPrecE (con_prec + 1) argL+                          `DAppE` (DVarE composeName+                                     `DAppE` infixOpE+                                     `DAppE` showsPrecE (con_prec + 1) argR))+     go (DNormalC _ tys) = do-      args <- mapM (const $ newUniqueName "arg") tys+      args   <- mapM (const $ newUniqueName "arg")   tys+      argTys <- mapM (const $ newUniqueName "argTy") tys       let show_args     = map (showsPrecE appPrec1) args           composed_args = foldr1 (\v q -> DVarE composeName                                            `DAppE` v@@ -89,9 +114,13 @@                                                      `DAppE` q)) show_args           named_args = DVarE composeName                          `DAppE` (DVarE showStringName-                                   `DAppE` dStringE (parenInfixConName con_name " "))+                                   `DAppE` dStringE (parenInfixConName con_name' " "))                          `DAppE` composed_args-      return $ DClause [DVarPa p, DConPa con_name $ map DVarPa args] $+      return $ DClause [ DVarP p+                       , DConP con_name' $+                         zipWith (mk_Show_arg_pat mode) args argTys+                       ] $+        mk_Show_rhs_sig mode argTys $         DVarE showParenName           `DAppE` (DVarE gtName `DAppE` DVarE p `DAppE` dIntegerE appPrec)           `DAppE` named_args@@ -101,10 +130,14 @@     go (DRecC []) = go (DNormalC False [])      go (DRecC tys) = do-      args <- mapM (const $ newUniqueName "arg") tys+      args   <- mapM (const $ newUniqueName "arg")   tys+      argTys <- mapM (const $ newUniqueName "argTy") tys       let show_args =             concatMap (\((arg_name, _, _), arg) ->-                        let arg_nameBase = nameBase arg_name+                        let arg_name'    = case mode of+                                             ForPromotion  -> arg_name+                                             ForShowSing{} -> singValName arg_name+                            arg_nameBase = nameBase arg_name'                             infix_rec    = showParen (isSym arg_nameBase)                                                      (showString arg_nameBase) ""                         in [ DVarE showStringName `DAppE` dStringE (infix_rec ++ " = ")@@ -112,16 +145,20 @@                            , DVarE showCommaSpaceName                            ])                       (zip tys args)-          brace_comma_args =   (DVarE showCharName `DAppE` dCharE '{')+          brace_comma_args =   (DVarE showCharName `DAppE` dCharE mode '{')                              : take (length show_args - 1) show_args           composed_args = foldr (\x y -> DVarE composeName `DAppE` x `DAppE` y)-                                (DVarE showCharName `DAppE` dCharE '}')+                                (DVarE showCharName `DAppE` dCharE mode '}')                                 brace_comma_args           named_args = DVarE composeName                          `DAppE` (DVarE showStringName-                                   `DAppE` dStringE (parenInfixConName con_name " "))+                                   `DAppE` dStringE (parenInfixConName con_name' " "))                          `DAppE` composed_args-      return $ DClause [DVarPa p, DConPa con_name $ map DVarPa args] $+      return $ DClause [ DVarP p+                       , DConP con_name' $+                         zipWith (mk_Show_arg_pat mode) args argTys+                       ] $+        mk_Show_rhs_sig mode argTys $         DVarE showParenName           `DAppE` (DVarE gtName `DAppE` DVarE p `DAppE` dIntegerE appPrec)           `DAppE` named_args@@ -136,9 +173,14 @@ showsPrecE :: Int -> Name -> DExp showsPrecE prec n = DVarE showsPrecName `DAppE` dIntegerE prec `DAppE` DVarE n -dCharE :: Char -> DExp-dCharE c = DLitE $ StringL [c] -- There aren't type-level characters yet,-                               -- so fake it with a string+dCharE :: ShowMode -> Char -> DExp+dCharE mode = DLitE . to_lit+  where+    to_lit :: Char -> Lit+    to_lit c = case mode of+                 ForPromotion  -> StringL [c] -- There aren't type-level characters yet,+                                              -- so fake it with a string+                 ForShowSing{} -> CharL c  dStringE :: String -> DExp dStringE = DLitE . StringL@@ -150,13 +192,54 @@ isSym ""      = False isSym (c : _) = startsVarSym c || startsConSym c +-----+-- ShowMode+-----++-- | Is a 'Show' instance being generated to be promoted/singled, or is it+-- being generated to create a 'Show' instance for a singleton type?+data ShowMode = ForPromotion      -- ^ For promotion/singling+              | ForShowSing Name  -- ^ For a 'Show' instance.+                                  --   Bundles the 'Name' of the data type.+ -- | Turn a context like @('Show' a, 'Show' b)@ into @('ShowSing' a, 'ShowSing' b)@.--- This is necessary for standalone-derived 'Show' instances for singleton types.-mkShowSingContext :: DCxt -> DCxt-mkShowSingContext = map show_to_SingShow+-- This is necessary for 'Show' instances for singleton types.+mkShowSingContext :: ShowMode -> DCxt -> DCxt+mkShowSingContext ForPromotion  = id+mkShowSingContext ForShowSing{} = map show_to_SingShow   where     show_to_SingShow :: DPred -> DPred-    show_to_SingShow = modifyConNameDPred $ \n ->+    show_to_SingShow = modifyConNameDType $ \n ->                          if n == showName                             then showSingName                             else n++mk_Show_name :: ShowMode -> Name+mk_Show_name ForPromotion  = showName+mk_Show_name ForShowSing{} = showSingName++-- If we're creating a 'Show' instance for a singleon type, decorate the type+-- appropriately (e.g., turn @Maybe a@ into @SMaybe (z :: Maybe a)@).+-- Otherwise, return the type (@Maybe a@) unchanged.+mk_Show_inst_ty :: Quasi q => ShowMode -> DType -> q DType+mk_Show_inst_ty ForPromotion           ty = pure ty+mk_Show_inst_ty (ForShowSing ty_tycon) ty = do+  z <- qNewName "z"+  pure $ DConT (singTyConName ty_tycon) `DAppT` (DVarT z `DSigT` ty)++-- If we're creating a 'Show' instance for a singleton type, create a pattern+-- of the form @(sx :: Sing x)@. Otherwise, simply return the pattern @sx@.+mk_Show_arg_pat :: ShowMode -> Name -> Name -> DPat+mk_Show_arg_pat ForPromotion  arg _      = DVarP arg+mk_Show_arg_pat ForShowSing{} arg arg_ty =+  DSigP (DVarP arg) (DConT singFamilyName `DAppT` DVarT arg_ty)++-- If we're creating a 'Show' instance for a singleton type, decorate the+-- expression with an explicit signature of the form+-- @e :: (ShowSing' a_1, ..., ShowSing' a_n) => ShowS@. Otherwise, return+-- the expression (@e@) unchanged.+mk_Show_rhs_sig :: ShowMode -> [Name] -> DExp -> DExp+mk_Show_rhs_sig ForPromotion  _            e = e+mk_Show_rhs_sig ForShowSing{} arg_ty_names e =+  e `DSigE` DForallT [] (map (DAppT (DConT showSing'Name) . DVarT) arg_ty_names)+                        (DConT showSName)
src/Data/Singletons/Deriving/Traversable.hs view
@@ -51,17 +51,17 @@       mk_trav_clause :: DCon -> q DClause       mk_trav_clause con = do         parts <- foldDataConArgs ft_trav con-        clause_for_con [DVarPa f] con =<< sequence parts+        clause_for_con [DVarP f] con =<< sequence parts        mk_trav :: q [DClause]       mk_trav = case cons of                   [] -> do v <- newUniqueName "v"-                           pure [DClause [DWildPa, DVarPa v]+                           pure [DClause [DWildP, DVarP v]                                          (DVarE pureName `DAppE` DCaseE (DVarE v) [])]                   _  -> traverse mk_trav_clause cons    trav_clauses <- mk_trav-  constraints <- inferConstraintsDef mb_ctxt (DConPr traversableName) ty cons+  constraints <- inferConstraintsDef mb_ctxt (DConT traversableName) ty cons   return $ InstDecl { id_cxt = constraints                     , id_name = traversableName                     , id_arg_tys = [ty]
src/Data/Singletons/Deriving/Util.hs view
@@ -16,12 +16,11 @@  import Control.Monad import Data.List-import Data.List.NonEmpty (NonEmpty(..))-import qualified Data.Set as Set import Data.Singletons.Names import Data.Singletons.Syntax import Data.Singletons.Util import Language.Haskell.TH.Desugar+import qualified Language.Haskell.TH.Desugar.OSet as OSet import Language.Haskell.TH.Syntax  -- A generic type signature for describing how to produce a derived instance.@@ -141,14 +140,20 @@                              inspect (DForallT _ _ t) = inspect t                              inspect (DSigT t _)      = inspect t                              inspect (DAppT t _)      = inspect t+                             inspect (DAppKindT t _)  = inspect t                              inspect (DVarT {})       = tyApp                              inspect DArrowT          = tyApp                              inspect (DLitT {})       = tyApp                              inspect DWildCardT       = tyApp -                         in case unfoldType f of-                              f_head :| _ -> inspect f_head+                         in case unfoldDType f of+                              (f_head, _) -> inspect f_head                     else trivial+    go (DAppKindT t k) = do+      (_, kc) <- go k+      if kc+         then pure (caseWrongArg, True)+         else go t     go (DSigT t k) = do       (_, kc) <- go k       if kc@@ -202,13 +207,13 @@     check_universal con@(DCon con_tvbs con_theta con_name _ res_ty)       | allowConstrainedLastTyVar       = pure ()-      | _ :| res_ty_args <- unfoldType res_ty-      , (_, last_res_ty_arg) <- snocView res_ty_args+      | (_, res_ty_args) <- unfoldDType res_ty+      , (_, last_res_ty_arg) <- snocView $ filterDTANormals res_ty_args       , Just last_tv <- getDVarTName_maybe last_res_ty_arg       = do ex_tvbs <- conExistentialTvbs (foldTypeTvbs (DConT n) data_tvbs) con            let univ_tvb_names = map extractTvbName con_tvbs \\ map extractTvbName ex_tvbs            if last_tv `elem` univ_tvb_names-                && last_tv `Set.notMember` foldMap (fvDType . predToType) con_theta+                && last_tv `OSet.notMember` foldMap fvDType con_theta               then pure ()               else fail $ badCon con_name existential       | otherwise@@ -243,7 +248,7 @@             , ft_forall  = \tvbs xs -> filter (\x -> all (not_in_ty x) tvbs) xs })   where     not_in_ty :: DType -> DTyVarBndr -> Bool-    not_in_ty ty tvb = extractTvbName tvb `Set.notMember` fvDType ty+    not_in_ty ty tvb = extractTvbName tvb `OSet.notMember` fvDType ty  -- Fold over the arguments of a data constructor in a Functor-like way. foldDataConArgs :: forall q a. DsMonad q => FFoldType a -> DCon -> q [a]@@ -253,8 +258,8 @@   where     foldArg :: DType -> q a     foldArg-      | _ :| res_ty_args <- unfoldType res_ty-      , (_, last_res_ty_arg) <- snocView res_ty_args+      | (_, res_ty_args) <- unfoldDType res_ty+      , (_, last_res_ty_arg) <- snocView $ filterDTANormals res_ty_args       , Just last_tv <- getDVarTName_maybe last_res_ty_arg       = functorLikeTraverse last_tv ft       | otherwise@@ -297,7 +302,7 @@                   -> q DClause mkSimpleConClause fold extra_pats (DCon _ _ con_name _ _) insides = do   vars_needed <- replicateM (length insides) $ newUniqueName "a"-  let pat = DConPa con_name (map DVarPa vars_needed)+  let pat = DConP con_name (map DVarP vars_needed)       rhs = fold con_name (zipWith (\i v -> i `DAppE` DVarE v) insides vars_needed)   pure $ DClause (extra_pats ++ [pat]) rhs
src/Data/Singletons/Internal.hs view
@@ -45,9 +45,62 @@ ---- Sing & friends -------------------------------------------------- ---------------------------------------------------------------------- --- | The singleton kind-indexed data family.-data family Sing :: k -> Type+-- | The singleton kind-indexed type family.+type family Sing :: k -> Type +{-+Note [The kind of Sing]+~~~~~~~~~~~~~~~~~~~~~~~+It is important to define Sing like this:++  type family Sing :: k -> Type++There are other conceivable ways to define Sing, but they all suffer from+various drawbacks:++* type family Sing :: forall k. k -> Type++  Surprisingly, this is /not/ equivalent to `type family Sing :: k -> Type`.+  The difference lies in their arity, i.e., the number of arguments that must+  be supplied in order to apply Sing. The former declaration has arity 0, while+  the latter has arity 1 (this is more obvious if you write the declaration as+  GHCi would display it with -fprint-explicit-kinds enabled:+  `type family Sing @k :: k -> Type`).++  The former declaration having arity 0 is actually what makes it useless. If+  we were to adopt an arity-0 definition of `Sing`, then in order to write+  `type instance Sing = SFoo`, GHC would require that `SFoo` must have the kind+  `forall k. k -> Type`, and moreover, the kind /must/ be polymorphic in `k`.+  This is undesirable, because in practice, every single `Sing` instance in the+  wild must monomorphize `k` (e.g., `SBool` monomorphizes it to `Bool`), so an+  arity-0 `Sing` simply won't work. In contrast, the current arity-1 definition+  of `Sing` /does/ let you monomorphize `k` in type family instances.++* type family Sing (a :: k) = (r :: Type) | r -> a++  Again, this is not equivalent to `type family Sing :: k -> Type`. This+  version of `Sing` has arity 2, since one must supply both `k` and `a` in+  order to apply it. While an arity-2 `Sing` is not suffer from the same+  polymorphism issues as the arity-0 `Sing` in the previous bullet point, it+  does suffer from another issue in that it cannot be partially applied. This+  is because its `a` argument /must/ be supplied, whereas with the arity-1+  `Sing`, it is perfectly admissible to write `Sing` without an explicit `a`+  argument. (Its invisible `k` argument is filled in automatically behind the+  scenes.)++* type family Sing = (r :: k -> Type) | r -> k++  This is the same as `type family Sing :: k -> Type`, but with an injectivity+  annotation. Technically, this definition isn't /wrong/, but the injectivity+  annotation is actually unnecessary. Because the return kind of `Sing` is+  declared to be `k -> Type`, the `Sing` type constructor is automatically+  injective, so `Sing a1 ~ Sing a2` implies `a1 ~~ a2`.++  Another way of phrasing this, using the terminology of Dependent Haskell, is+  that the arrow in `Sing`'s return kind is /matchable/, which implies that+  `Sing` is an injective type constructor as a consequence.+-}+ -- | A 'SingI' constraint is essentially an implicitly-passed singleton. -- If you need to satisfy this constraint with an explicit singleton, please -- see 'withSingI' or the 'Sing' pattern synonym.@@ -144,6 +197,39 @@   where FromSing sng = fromSing sng  ----------------------------------------------------------------------+---- WrappedSing -----------------------------------------------------+----------------------------------------------------------------------++-- | A newtype around 'Sing'.+--+-- Since 'Sing' is a type family, it cannot be used directly in type class+-- instances. As one example, one cannot write a catch-all+-- @instance 'SDecide' k => 'TestEquality' ('Sing' k)@. On the other hand,+-- 'WrappedSing' is a perfectly ordinary data type, which means that it is+-- quite possible to define an+-- @instance 'SDecide' k => 'TestEquality' ('WrappedSing' k)@.+newtype WrappedSing :: forall k. k -> Type where+  WrapSing :: forall k (a :: k). { unwrapSing :: Sing a } -> WrappedSing a++-- | The singleton for 'WrappedSing's. Informally, this is the singleton type+-- for other singletons.+newtype SWrappedSing :: forall k (a :: k). WrappedSing a -> Type where+  SWrapSing :: forall k (a :: k) (ws :: WrappedSing a).+               { sUnwrapSing :: Sing a } -> SWrappedSing ws+type instance Sing = SWrappedSing++type family UnwrapSing (ws :: WrappedSing a) :: Sing a where+  UnwrapSing ('WrapSing s) = s++instance SingKind (WrappedSing a) where+  type Demote (WrappedSing a) = WrappedSing a+  fromSing (SWrapSing s) = WrapSing s+  toSing (WrapSing s) = SomeSing $ SWrapSing s++instance forall a (s :: Sing a). SingI a => SingI ('WrapSing s) where+  sing = SWrapSing sing++---------------------------------------------------------------------- ---- SingInstance ---------------------------------------------------- ---------------------------------------------------------------------- @@ -201,11 +287,39 @@ -- here because dealing with inequality like this is hard, and -- I (Richard) wasn't sure what concrete value the ticket would -- have, given that we don't know how to begin fixing it.-type family ApplyTyCon (f :: k1 -> k2) (x :: k1) :: k3 where-  ApplyTyCon (f :: k1 -> k2 -> k3) x = TyCon (f x)-  ApplyTyCon f x                     = f x+type family ApplyTyCon :: (k1 -> k2) -> (k1 ~> unmatchable_fun) where+  ApplyTyCon @k1 @(k2 -> k3) @unmatchable_fun = ApplyTyConAux2+  ApplyTyCon @k1 @k2         @k2              = ApplyTyConAux1+-- Upon first glance, the definition of ApplyTyCon (as well as the+-- corresponding Apply instance for TyCon) seems a little indirect. One might+-- wonder why these aren't defined like so:+--+--   type family ApplyTyCon (f :: k1 -> k2) (x :: k1) :: k3 where+--     ApplyTyCon (f :: k1 -> k2 -> k3) x = TyCon (f x)+--     ApplyTyCon f x                     = f x+--+--   type instance Apply (TyCon f) x = ApplyTyCon f x+--+-- This also works, but it requires that ApplyTyCon always be applied to a+-- minimum of two arguments. In particular, this rules out a trick that we use+-- elsewhere in the library to write SingI instances for different TyCons,+-- which relies on partial applications of ApplyTyCon:+--+--   instance forall k1 k2 (f :: k1 -> k2).+--            ( forall a. SingI a => SingI (f a)+--            , (ApplyTyCon :: (k1 -> k2) -> (k1 ~> k2)) ~ ApplyTyConAux1+--            ) => SingI (TyCon1 f) where+type instance Apply (TyCon f) x = ApplyTyCon f @@ x -type instance Apply (TyCon f) x = ApplyTyCon f x+-- | An \"internal\" defunctionalization symbol used primarily in the+-- definition of 'ApplyTyCon', as well as the 'SingI' instances for 'TyCon1',+-- 'TyCon2', etc.+data ApplyTyConAux1 :: (k1 -> k2) -> (k1 ~> k2)+-- | An \"internal\" defunctionalization symbol used primarily in the+-- definition of 'ApplyTyCon'.+data ApplyTyConAux2 :: (k1 -> k2 -> k3) -> (k1 ~> unmatchable_fun)+type instance Apply (ApplyTyConAux1 f) x = f x+type instance Apply (ApplyTyConAux2 f) x = TyCon (f x)  -- | Wrapper for converting the normal type-level arrow into a '~>'. -- For example, given:@@ -237,8 +351,9 @@ ---- Defunctionalized Sing instance and utilities -------------------- ---------------------------------------------------------------------- -newtype instance Sing (f :: k1 ~> k2) =+newtype SLambda (f :: k1 ~> k2) =   SLambda { applySing :: forall t. Sing t -> Sing (f @@ t) }+type instance Sing = SLambda  -- | An infix synonym for `applySing` (@@) :: forall k1 k2 (f :: k1 ~> k2) (t :: k1). Sing f -> Sing t -> Sing (f @@ t)
src/Data/Singletons/Names.hs view
@@ -18,6 +18,8 @@ import GHC.TypeLits ( Nat, Symbol ) import GHC.Exts ( Constraint ) import GHC.Show ( showCommaSpace, showSpace )+import Data.Type.Equality ( TestEquality(..) )+import Data.Type.Coercion ( TestCoercion(..) ) import Data.Typeable ( TypeRep ) import Data.Singletons.Util import Control.Applicative@@ -26,13 +28,16 @@ boolName, andName, tyEqName, compareName, minBoundName,   maxBoundName, repName,   nilName, consName, listName, tyFunArrowName,-  applyName, natName, symbolName, typeRepName, stringName,+  applyName, applyTyConName, applyTyConAux1Name,+  natName, symbolName, typeRepName, stringName,   eqName, ordName, boundedName, orderingName,-  singFamilyName, singIName, singMethName, demoteName,+  singFamilyName, singIName, singMethName, demoteName, withSingIName,   singKindClassName, sEqClassName, sEqMethName, sconsName, snilName, strueName,   sIfName,   someSingTypeName, someSingDataName,   sListName, sDecideClassName, sDecideMethName,+  testEqualityClassName, testEqualityMethName, decideEqualityName,+  testCoercionClassName, testCoercionMethName, decideCoercionName,   provedName, disprovedName, reflName, toSingName, fromSingName,   equalityName, applySingName, suppressClassName, suppressMethodName,   thenCmpName,@@ -40,8 +45,8 @@   sNegateName, errorName, foldlName, cmpEQName, cmpLTName, cmpGTName,   singletonsToEnumName, singletonsFromEnumName, enumName, singletonsEnumName,   equalsName, constraintName,-  showName, showCharName, showCommaSpaceName, showParenName, showsPrecName,-  showSpaceName, showStringName, showSingName,+  showName, showSName, showCharName, showCommaSpaceName, showParenName, showsPrecName,+  showSpaceName, showStringName, showSingName, showSing'Name,   composeName, gtName, tyFromStringName, sFromStringName,   foldableName, foldMapName, memptyName, mappendName, foldrName,   functorName, fmapName, replaceName,@@ -58,6 +63,8 @@ listName = ''[] tyFunArrowName = ''(~>) applyName = ''Apply+applyTyConName = ''ApplyTyCon+applyTyConAux1Name = ''ApplyTyConAux1 symbolName = ''Symbol natName = ''Nat typeRepName = ''TypeRep@@ -72,6 +79,7 @@ toSingName = 'toSing fromSingName = 'fromSing demoteName = ''Demote+withSingIName = 'withSingI singKindClassName = ''SingKind sEqClassName = mk_name_tc "Data.Singletons.Prelude.Eq" "SEq" sEqMethName = mk_name_v "Data.Singletons.Prelude.Eq" "%=="@@ -84,6 +92,12 @@ sListName = mk_name_tc "Data.Singletons.Prelude.Instances" "SList" sDecideClassName = ''SDecide sDecideMethName = '(%~)+testEqualityClassName = ''TestEquality+testEqualityMethName = 'testEquality+decideEqualityName = 'decideEquality+testCoercionClassName = ''TestCoercion+testCoercionMethName = 'testCoercion+decideCoercionName = 'decideCoercion provedName = 'Proved disprovedName = 'Disproved reflName = 'Refl@@ -109,12 +123,14 @@ equalsName = '(==) constraintName = ''Constraint showName = ''Show+showSName = ''ShowS showCharName = 'showChar showParenName = 'showParen showSpaceName = 'showSpace showsPrecName = 'showsPrec showStringName = 'showString showSingName = mk_name_tc "Data.Singletons.ShowSing" "ShowSing"+showSing'Name = mk_name_tc "Data.Singletons.ShowSing" "ShowSing'" composeName = '(.) gtName = '(>) showCommaSpaceName = 'showCommaSpace@@ -161,13 +177,7 @@  -- like promoteValNameLhs, but adds a prefix to the promoted name promoteValNameLhsPrefix :: (String, String) -> Name -> Name-promoteValNameLhsPrefix pres@(alpha, symb) n-  | nameBase n == "."-  = mkName $ symb ++ ":."-  | nameBase n == "!"-  = mkName $ symb ++ ":!"-    -- See Note [Special cases for (.) and (!)]-+promoteValNameLhsPrefix pres@(alpha, _) n     -- We can't promote promote idenitifers beginning with underscores to     -- type names, so we work around the issue by prepending "US" at the     -- front of the name (#229).@@ -193,15 +203,6 @@ -- names. promoteTySym :: Name -> Int -> Name promoteTySym name sat-    | nameBase name == ":."-    = default_case (mkName ".")-    | nameBase name == ":!"-    = default_case (mkName "!")-      -- Although (:.) and (:!) are special cases, we need not have a colon in-      -- front of their defunctionalization symbols, since only the names-      -- (.) and (!) are problematic for the parser.-      -- See Note [Special cases for (.) and (!)]-       -- We can't promote promote idenitifers beginning with underscores to       -- type names, so we work around the issue by prepending "US" at the       -- front of the name (#229).@@ -285,7 +286,7 @@ singFamily = DConT singFamilyName  singKindConstraint :: DKind -> DPred-singKindConstraint = DAppPr (DConPr singKindClassName)+singKindConstraint = DAppT (DConT singKindClassName)  demote :: DType demote = DConT demoteName@@ -302,9 +303,9 @@ foldApply :: DType -> [DType] -> DType foldApply = foldl apply --- make and equality predicate+-- make an equality predicate mkEqPred :: DType -> DType -> DPred-mkEqPred ty1 ty2 = foldPred (DConPr equalityName) [ty1, ty2]+mkEqPred ty1 ty2 = foldType (DConT equalityName) [ty1, ty2]  -- | If a 'String' begins with one or more underscores, return -- @'Just' (us, rest)@, where @us@ contain all of the underscores at the@@ -315,16 +316,19 @@                        ([], _) -> Nothing                        res     -> Just res --- Walk a DPred, applying a function to all occurrences of constructor names.-modifyConNameDPred :: (Name -> Name) -> DPred -> DPred-modifyConNameDPred mod_con_name = go+-- Walk a DType, applying a function to all occurrences of constructor names.+modifyConNameDType :: (Name -> Name) -> DType -> DType+modifyConNameDType mod_con_name = go   where-    go (DForallPr tvbs cxt p) = DForallPr tvbs (map go cxt) (go p)-    go (DAppPr p t)           = DAppPr (go p) t-    go (DSigPr p k)           = DSigPr (go p) k-    go p@(DVarPr _)           = p-    go (DConPr n)             = DConPr (mod_con_name n)-    go p@DWildCardPr          = p+    go (DForallT tvbs cxt p) = DForallT tvbs (map go cxt) (go p)+    go (DAppT     p t)       = DAppT     (go p) t+    go (DAppKindT p k)       = DAppKindT (go p) k+    go (DSigT     p k)       = DSigT     (go p) k+    go p@(DVarT _)           = p+    go (DConT n)             = DConT (mod_con_name n)+    go p@DWildCardT          = p+    go p@(DLitT {})          = p+    go p@DArrowT             = p  {- Note [Defunctionalization symbol suffixes]@@ -351,12 +355,4 @@ $@#@$$  And there is no conflict.--Note [Special cases for (.) and (!)]-~~~~~~~~~~~~~~~~~~~~~~~~~~~-Almost every infix value name can be promoted trivially. For example, (+) works-both at the value- and type-level. The two exceptions to this rule are (.) and (!),-which we promote to the special type names (:.) and (:!), respectively.-This is necessary since one cannot define or apply (.) or (!) at the type level ---they simply won't parse. Bummer. -}
src/Data/Singletons/Partition.hs view
@@ -30,15 +30,15 @@ import Language.Haskell.TH.Syntax hiding (showName) import Language.Haskell.TH.Ppr import Language.Haskell.TH.Desugar+import qualified Language.Haskell.TH.Desugar.OMap.Strict as OMap+import Language.Haskell.TH.Desugar.OMap.Strict (OMap) import Data.Singletons.Util  import Control.Monad import Data.Bifunctor (bimap)-import Data.List.NonEmpty (NonEmpty(..)) import qualified Data.Map as Map import Data.Map (Map) import Data.Maybe-import Data.Semigroup (Semigroup(..))  data PartitionedDecs =   PDecs { pd_let_decs :: [DLetDec]@@ -77,7 +77,7 @@   derived_decs     <- mapM (\(strat, deriv_pred) ->               let etad_tvbs-                    | DConT pred_name :| _ <- unfoldType deriv_pred+                    | (DConT pred_name, _) <- unfoldDType deriv_pred                     , isFunctorLikeClassName pred_name                       -- If deriving Functor, Foldable, or Traversable,                       -- we need to use one less type variable than we normally do.@@ -89,9 +89,9 @@       $ concatMap flatten_clause derivings   return $ mconcat $ derived_dec : derived_decs   where-    flatten_clause :: DDerivClause -> [(Maybe DDerivStrategy, DType)]+    flatten_clause :: DDerivClause -> [(Maybe DDerivStrategy, DPred)]     flatten_clause (DDerivClause strat preds) =-      map (\p -> (strat, predToType p)) preds+      map (\p -> (strat, p)) preds  partitionDec (DClassD cxt name tvbs fds decs) = do   (lde, otfs) <- concatMapM partitionClassDec decs@@ -101,7 +101,7 @@                                                , cd_fds       = fds                                                , cd_lde       = lde }]                   , pd_open_type_family_decs = otfs }-partitionDec (DInstanceD _ cxt ty decs) = do+partitionDec (DInstanceD _ _ cxt ty decs) = do   (defns, sigs) <- liftM (bimap catMaybes mconcat) $                    mapAndUnzipM partitionInstanceDec decs   (name, tys) <- split_app_tys [] ty@@ -116,9 +116,9 @@     split_app_tys acc (DSigT t _)   = split_app_tys acc t     split_app_tys _ _ = fail $ "Illegal instance head: " ++ show ty partitionDec (DRoleAnnotD {}) = return mempty  -- ignore these-partitionDec (DTySynD name tvbs _type) =+partitionDec (DTySynD name tvbs rhs) =   -- See Note [Partitioning, type synonyms, and type families]-  pure $ mempty { pd_ty_syn_decs = [TySynDecl name tvbs] }+  pure $ mempty { pd_ty_syn_decs = [TySynDecl name tvbs rhs] } partitionDec (DClosedTypeFamilyD tf_head _) =   -- See Note [Partitioning, type synonyms, and type families]   pure $ mempty { pd_closed_type_family_decs = [TypeFamilyDecl tf_head] }@@ -128,13 +128,14 @@ partitionDec (DTySynInstD {}) = pure mempty   -- There's no need to track type family instances, since   -- we already record the type family itself separately.-partitionDec (DStandaloneDerivD mb_strat ctxt ty) =-  case unfoldType ty of-    cls_pred_ty :| cls_tys-      | not (null cls_tys) -- We can't handle zero-parameter type classes-      , let cls_arg_tys  = init cls_tys-            data_ty      = last cls_tys-            data_ty_head = case unfoldType data_ty of ty_head :| _ -> ty_head+partitionDec (DStandaloneDerivD mb_strat _ ctxt ty) =+  case unfoldDType ty of+    (cls_pred_ty, cls_tys)+      | let cls_normal_tys = filterDTANormals cls_tys+      , not (null cls_normal_tys) -- We can't handle zero-parameter type classes+      , let cls_arg_tys  = init cls_normal_tys+            data_ty      = last cls_normal_tys+            data_ty_head = case unfoldDType data_ty of (ty_head, _) -> ty_head       , DConT data_tycon <- data_ty_head -- We can't handle deriving an instance for something                                          -- other than a type constructor application       -> do let cls_pred = foldType cls_pred_ty cls_arg_tys@@ -152,10 +153,10 @@ partitionDec dec =   fail $ "Declaration cannot be promoted: " ++ pprint (decToTH dec) -partitionClassDec :: Monad m => DDec -> m (ULetDecEnv, [OpenTypeFamilyDecl])+partitionClassDec :: MonadFail m => DDec -> m (ULetDecEnv, [OpenTypeFamilyDecl]) partitionClassDec (DLetDec (DSigD name ty)) =   pure (typeBinding name ty, mempty)-partitionClassDec (DLetDec (DValD (DVarPa name) exp)) =+partitionClassDec (DLetDec (DValD (DVarP name) exp)) =   pure (valueBinding name (UValue exp), mempty) partitionClassDec (DLetDec (DFunD name clauses)) =   pure (valueBinding name (UFunction clauses), mempty)@@ -173,16 +174,16 @@ partitionClassDec _ =   fail "Only method declarations can be promoted within a class." -partitionInstanceDec :: Monad m => DDec+partitionInstanceDec :: MonadFail m => DDec                      -> m ( Maybe (Name, ULetDecRHS) -- right-hand sides of methods-                          , Map Name DType           -- method type signatures+                          , OMap Name DType          -- method type signatures                           )-partitionInstanceDec (DLetDec (DValD (DVarPa name) exp)) =+partitionInstanceDec (DLetDec (DValD (DVarP name) exp)) =   pure (Just (name, UValue exp), mempty) partitionInstanceDec (DLetDec (DFunD name clauses)) =   pure (Just (name, UFunction clauses), mempty) partitionInstanceDec (DLetDec (DSigD name ty)) =-  pure (Nothing, Map.singleton name ty)+  pure (Nothing, OMap.singleton name ty) partitionInstanceDec (DLetDec (DPragmaD {})) =   pure (Nothing, mempty) partitionInstanceDec (DTySynInstD {}) =@@ -196,7 +197,7 @@   :: forall m. DsMonad m   => Maybe DDerivStrategy                 -- ^ The deriving strategy, if present.-  -> DType      -- ^ The class being derived (e.g., 'Eq'), possibly applied to+  -> DPred      -- ^ The class being derived (e.g., 'Eq'), possibly applied to                 --   some number of arguments (e.g., @C Int Bool@).   -> Maybe DCxt -- ^ @'Just' ctx@ if @ctx@ was provided via @StandaloneDeriving@.                 --   'Nothing' if using a @deriving@ clause.@@ -204,8 +205,8 @@   -> DataDecl   -- ^ The original data type information (e.g., its constructors).   -> m PartitionedDecs partitionDeriving mb_strat deriv_pred mb_ctxt ty data_decl =-  case unfoldType deriv_pred of-    DConT deriv_name :| arg_tys+  case unfoldDType deriv_pred of+    (DConT deriv_name, arg_tys)          -- Here, we are more conservative than GHC: DeriveAnyClass only kicks          -- in if the user explicitly chooses to do so with the anyclass          -- deriving strategy@@ -223,7 +224,7 @@                       -- StandaloneDeriving, use that.)                      , id_name      = deriv_name-                    , id_arg_tys   = arg_tys ++ [ty]+                    , id_arg_tys   = filterDTANormals arg_tys ++ [ty]                     , id_sigs      = mempty                     , id_meths     = [] } @@ -237,7 +238,7 @@      -- Stock classes. These are derived only if `singletons` supports them     -- (and, optionally, if an explicit stock deriving strategy is used)-    DConT deriv_name :| [] -- For now, all stock derivable class supported in+    (DConT deriv_name, []) -- For now, all stock derivable class supported in                            -- singletons take just one argument (the data                            -- type itself)        | stock_or_default@@ -258,9 +259,17 @@        mk_derived_inst    dec = mempty { pd_instance_decs   = [dec] }       mk_derived_eq_inst dec = mempty { pd_derived_eq_decs = [dec] }-      derived_decl = DerivedDecl { ded_mb_cxt = mb_ctxt-                                 , ded_type   = ty-                                 , ded_decl   = data_decl }++      derived_decl :: DerivedDecl cls+      derived_decl = DerivedDecl { ded_mb_cxt     = mb_ctxt+                                 , ded_type       = ty+                                 , ded_type_tycon = ty_tycon+                                 , ded_decl       = data_decl }+        where+          ty_tycon :: Name+          ty_tycon = case unfoldDType ty of+                       (DConT tc, _) -> tc+                       (t,        _) -> error $ "Not a data type: " ++ show t       stock_or_default = isStockOrDefault mb_strat        -- A mapping from all stock derivable classes (that singletons supports)@@ -277,7 +286,7 @@         , ( eqName, return $ mk_derived_eq_inst derived_decl )           -- See Note [DerivedDecl] in Data.Singletons.Syntax         , ( showName, do -- These will become PShow/SShow instances...-                         inst_for_promotion <- mk_instance mkShowInstance+                         inst_for_promotion <- mk_instance $ mkShowInstance ForPromotion                          -- ...and this will become a Show instance.                          let inst_for_show = derived_decl                          pure $ mempty { pd_instance_decs     = [inst_for_promotion]
src/Data/Singletons/Prelude.hs view
@@ -22,15 +22,11 @@   -- * Basic singleton definitions   module Data.Singletons, -  Sing(SFalse, STrue, SNil, SCons, SJust, SNothing, SLeft, SRight, SLT, SEQ, SGT,-       STuple0, STuple2, STuple3, STuple4, STuple5, STuple6, STuple7),--  -- * Singleton type synonyms+  -- * Singleton types -  -- | These synonyms are all kind-restricted synonyms of 'Sing'.-  -- For example 'SBool' requires an argument of kind 'Bool'.-  SBool, SList, SMaybe, SEither, SOrdering,-  STuple0, STuple2, STuple3, STuple4, STuple5, STuple6, STuple7,+  SBool(..), SList(..), SMaybe(..), SEither(..), SOrdering(..),+  STuple0(..), STuple2(..), STuple3(..), STuple4(..),+  STuple5(..), STuple6(..), STuple7(..),    -- * Functions working with 'Bool'   If, sIf, Not, sNot, type (&&), type (||), (%&&), (%||), Otherwise, sOtherwise,@@ -65,12 +61,14 @@   PSemigroup(type (<>)), SSemigroup((%<>)),   PMonoid(..), SMonoid(..), -  -- * Singleton 'Functor', 'Applicative', and 'Monad'+  -- * Singleton 'Functor', 'Applicative', 'Monad', and 'MonadFail'   PFunctor(Fmap, type (<$)), SFunctor(sFmap, (%<$)), type (<$>), (%<$>),   PApplicative(Pure, type (<*>), type (*>), type (<*)),   SApplicative(sPure, (%<*>), (%*>), (%<*)),-  PMonad(type (>>=), type (>>), Return, Fail),-  SMonad((%>>=), (%>>), sReturn, sFail),+  PMonad(type (>>=), type (>>), Return),+  SMonad((%>>=), (%>>), sReturn),+  PMonadFail(Fail), SMonadFail(sFail),+   MapM_, sMapM_,   Sequence_, sSequence_,   type (=<<), (%=<<),@@ -84,7 +82,7 @@   STraversable(sTraverse, sSequenceA, sMapM, sSequence),    -- ** Miscellaneous functions-  Id, sId, Const, sConst, (:.), (%.), type ($), (%$), type ($!), (%$!),+  Id, sId, Const, sConst, type (.), (%.), type ($), (%$), type ($!), (%$!),   Flip, sFlip, AsTypeOf, sAsTypeOf,   Seq, sSeq,
src/Data/Singletons/Prelude/Applicative.hs view
@@ -6,6 +6,7 @@ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -27,7 +28,7 @@ module Data.Singletons.Prelude.Applicative (   PApplicative(..), SApplicative(..),   PAlternative(..), SAlternative(..),-  Sing (SConst, sGetConst), SConst, Const, GetConst,+  Sing, SConst(..), Const, GetConst,   type (<$>), (%<$>), type (<$), (%<$), type (<**>), (%<**>),   LiftA, sLiftA, LiftA3, sLiftA3, Optional, sOptional,
src/Data/Singletons/Prelude/Base.hs view
@@ -1,6 +1,6 @@ {-# LANGUAGE TemplateHaskell, TypeOperators, DataKinds, PolyKinds,              ScopedTypeVariables, TypeFamilies, GADTs,-             UndecidableInstances, BangPatterns #-}+             UndecidableInstances, BangPatterns, TypeApplications #-}  ----------------------------------------------------------------------------- -- |@@ -24,7 +24,7 @@ module Data.Singletons.Prelude.Base (   -- * Basic functions   Foldr, sFoldr, Map, sMap, type (++), (%++), Otherwise, sOtherwise,-  Id, sId, Const, sConst, (:.), (%.), type ($), type ($!), (%$), (%$!),+  Id, sId, Const, sConst, type (.), (%.), type ($), type ($!), (%$), (%$!),   Until, sUntil, Flip, sFlip, AsTypeOf, sAsTypeOf,   Seq, sSeq, @@ -111,5 +111,6 @@  -- Workaround for #326 infixr 5 +++infixr 9 . infixr 0 $ infixr 0 $!
src/Data/Singletons/Prelude/Bool.hs view
@@ -24,16 +24,7 @@  module Data.Singletons.Prelude.Bool (   -- * The 'Bool' singleton--  Sing(SFalse, STrue),-  -- | Though Haddock doesn't show it, the 'Sing' instance above declares-  -- constructors-  ---  -- > SFalse :: Sing False-  -- > STrue  :: Sing True--  SBool,-  -- | 'SBool' is a kind-restricted synonym for 'Sing': @type SBool (a :: Bool) = Sing a@+  Sing, SBool(..),    -- * Conditionals   If, sIf,
src/Data/Singletons/Prelude/Const.hs view
@@ -1,11 +1,11 @@ {-# LANGUAGE DataKinds #-}-{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE InstanceSigs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -26,8 +26,7 @@  module Data.Singletons.Prelude.Const (   -- * The 'Const' singleton-  Sing(SConst, sGetConst),-  SConst, GetConst,+  Sing, SConst(..), GetConst,    -- * Defunctionalization symbols   ConstSym0, ConstSym1,@@ -71,9 +70,9 @@ poly-kinded Sing instances (see #150), we simply write the Sing instance by hand. -}-data instance Sing :: forall (k :: Type) (a :: Type) (b :: k). Const a b -> Type where-  SConst :: { sGetConst :: Sing a } -> Sing ('Const a)-type SConst = (Sing :: Const a b -> Type)+data SConst :: forall (k :: Type) (a :: Type) (b :: k). Const a b -> Type where+  SConst :: { sGetConst :: Sing a } -> SConst ('Const a)+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)@@ -83,8 +82,6 @@  $(genDefunSymbols [''Const]) instance SingI ConstSym0 where-  sing = singFun1 SConst-instance SingI (TyCon1 'Const) where   sing = singFun1 SConst  $(singletons [d|
src/Data/Singletons/Prelude/Either.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeFamilies, GADTs,-             RankNTypes, UndecidableInstances, DataKinds, PolyKinds #-}+             RankNTypes, UndecidableInstances, DataKinds, PolyKinds,+             TypeApplications #-}  ----------------------------------------------------------------------------- -- |@@ -23,16 +24,7 @@  module Data.Singletons.Prelude.Either (   -- * The 'Either' singleton-  Sing(SLeft, SRight),-  -- | Though Haddock doesn't show it, the 'Sing' instance above declares-  -- constructors-  ---  -- > SLeft  :: Sing a -> Sing (Left a)-  -- > SRight :: Sing b -> Sing (Right b)--  SEither,-  -- | 'SEither' is a kind-restricted synonym for 'Sing':-  -- @type SEither (a :: Either x y) = Sing a@+  Sing, SEither(..),    -- * Singletons from @Data.Either@   either_, Either_, sEither_,
src/Data/Singletons/Prelude/Enum.hs view
@@ -1,7 +1,7 @@ {-# LANGUAGE TemplateHaskell, DataKinds, PolyKinds, ScopedTypeVariables,              TypeFamilies, TypeOperators, GADTs, UndecidableInstances,              FlexibleContexts, DefaultSignatures, BangPatterns,-             InstanceSigs #-}+             InstanceSigs, TypeApplications #-}  ----------------------------------------------------------------------------- -- |
src/Data/Singletons/Prelude/Foldable.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -107,7 +108,8 @@ import Data.Singletons.Prelude.Bool import Data.Singletons.Prelude.Either import Data.Singletons.Prelude.Eq-import Data.Singletons.Prelude.Instances (Sing(..), type (:@#@$))+import Data.Singletons.Prelude.Instances+  hiding (Foldl, FoldlSym0(..), FoldlSym1(..), FoldlSym2(..), FoldlSym3, sFoldl) import Data.Singletons.Prelude.List.Internal.Disambiguation import Data.Singletons.Prelude.Maybe import Data.Singletons.Prelude.Monad.Internal@@ -132,8 +134,9 @@ import Data.Singletons.TypeLits.Internal  newtype Endo a = Endo (a ~> a)-data instance Sing :: forall a. Endo a -> Type where-  SEndo :: Sing x -> Sing ('Endo x)+data SEndo :: forall a. Endo a -> Type where+  SEndo :: Sing x -> SEndo ('Endo x)+type instance Sing = SEndo data EndoSym0 :: forall a. (a ~> a) ~> Endo a type instance Apply EndoSym0 x = 'Endo x @@ -146,13 +149,15 @@   |])  newtype MaxInternal a = MaxInternal (Maybe a)-data instance Sing :: forall a. MaxInternal a -> Type where-  SMaxInternal :: Sing x -> Sing ('MaxInternal x)+data SMaxInternal :: forall a. MaxInternal a -> Type where+  SMaxInternal :: Sing x -> SMaxInternal ('MaxInternal x)+type instance Sing = SMaxInternal $(genDefunSymbols [''MaxInternal])  newtype MinInternal a = MinInternal (Maybe a)-data instance Sing :: forall a. MinInternal a -> Type where-  SMinInternal :: Sing x -> Sing ('MinInternal x)+data SMinInternal :: forall a. MinInternal a -> Type where+  SMinInternal :: Sing x -> SMinInternal ('MinInternal x)+type instance Sing = SMinInternal $(genDefunSymbols [''MinInternal])  $(singletonsOnly [d|
src/Data/Singletons/Prelude/Function.hs view
@@ -19,11 +19,11 @@  {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeFamilies,              TypeOperators, UndecidableInstances, GADTs,-             DataKinds, PolyKinds #-}+             DataKinds, PolyKinds, TypeApplications #-}  module Data.Singletons.Prelude.Function (     -- * "Prelude" re-exports-    Id, sId, Const, sConst, (:.), (%.), Flip, sFlip, type ($), (%$)+    Id, sId, Const, sConst, type (.), (%.), Flip, sFlip, type ($), (%$)     -- * Other combinators   , type (&), (%&), On, sOn
src/Data/Singletons/Prelude/Functor.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Singletons/Prelude/Identity.hs view
@@ -6,6 +6,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -Wno-orphans #-}@@ -25,8 +26,7 @@  module Data.Singletons.Prelude.Identity (   -- * The 'Identity' singleton-  Sing(SIdentity, sRunIdentity),-  SIdentity, RunIdentity,+  Sing, SIdentity(..), RunIdentity,    -- * Defunctionalization symbols   IdentitySym0, IdentitySym1,
src/Data/Singletons/Prelude/Instances.hs view
@@ -10,11 +10,16 @@  {-# LANGUAGE DataKinds, PolyKinds, RankNTypes, GADTs, TypeFamilies, EmptyCase,              FlexibleContexts, TemplateHaskell, ScopedTypeVariables,-             UndecidableInstances, TypeOperators, FlexibleInstances #-}+             UndecidableInstances, TypeOperators, FlexibleInstances,+             TypeApplications #-} {-# OPTIONS_GHC -Wno-orphans #-} -module Data.Singletons.Prelude.Instances where+module Data.Singletons.Prelude.Instances (+    module Data.Singletons.Prelude.Instances+  , Sing+  ) where +import Data.Singletons.Internal import Data.Singletons.Single import Data.Singletons.Util
src/Data/Singletons/Prelude/IsString.hs view
@@ -4,6 +4,7 @@ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Singletons/Prelude/List.hs view
@@ -22,15 +22,7 @@  module Data.Singletons.Prelude.List (   -- * The singleton for lists-  Sing(SNil, SCons),-  -- | Though Haddock doesn't show it, the 'Sing' instance above declares-  -- constructors-  ---  -- > SNil  :: Sing '[]-  -- > SCons :: Sing (h :: k) -> Sing (t :: [k]) -> Sing (h ': t)--  SList,-  -- | 'SList' is a kind-restricted synonym for 'Sing': @type SList (a :: [k]) = Sing a@+  Sing, SList(..),    -- * Basic functions   type (++), (%++), Head, sHead, Last, sLast, Tail, sTail, Init, sInit,@@ -267,7 +259,7 @@        ) import Data.Singletons.Prelude.Foldable import Data.Singletons.Prelude.Instances-       (Sing(..), SList, NilSym0, type (:@#@$), type (:@#@$$), type (:@#@$$$))+       (Sing, SList(..), NilSym0, type (:@#@$), type (:@#@$$), type (:@#@$$$)) import Data.Singletons.Prelude.Traversable  import Data.Singletons.Prelude.List.Internal
src/Data/Singletons/Prelude/List/Internal.hs view
@@ -1,6 +1,7 @@ {-# LANGUAGE TypeOperators, DataKinds, PolyKinds, TypeFamilies,              TemplateHaskell, GADTs, UndecidableInstances, RankNTypes,-             ScopedTypeVariables, FlexibleContexts, AllowAmbiguousTypes #-}+             ScopedTypeVariables, FlexibleContexts,+             TypeApplications #-} {-# OPTIONS_GHC -O0 #-}  -----------------------------------------------------------------------------@@ -96,11 +97,6 @@       perms (t:ts) is = foldr interleave (perms ts (t:is)) (permutations is)         where interleave    xs     r = let (_,zs) = interleave' id xs r in zs -              -- This type signature isn't present in the reference-              -- implementation of permutations in base. However, it is needed-              -- here, since (at least in GHC 8.2.1) the singletonized version-              -- will fail to typecheck without it. See #13549 for the full story.-              interleave' :: ([a] -> b) -> [a] -> [b] -> ([a], [b])               interleave' _ []     r = (ts, r)               interleave' f (y:ys) r = let (us,zs) = interleave' (f . (y:)) ys r                                        in  (y:us, f (t:y:us) : zs)
src/Data/Singletons/Prelude/List/Internal/Disambiguation.hs view
@@ -13,7 +13,8 @@ ----------------------------------------------------------------------------  {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeFamilies,-             UndecidableInstances, GADTs, DataKinds, PolyKinds #-}+             UndecidableInstances, GADTs, DataKinds, PolyKinds,+             TypeApplications #-} {-# OPTIONS_GHC -Wno-missing-signatures #-}  module Data.Singletons.Prelude.List.Internal.Disambiguation where
src/Data/Singletons/Prelude/List/NonEmpty.hs view
@@ -1,6 +1,6 @@ {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeOperators,              TypeFamilies, GADTs, UndecidableInstances, InstanceSigs,-             DataKinds, PolyKinds #-}+             DataKinds, PolyKinds, TypeApplications #-} {-# OPTIONS_GHC -Wno-orphans #-}  -----------------------------------------------------------------------------@@ -25,17 +25,7 @@  module Data.Singletons.Prelude.List.NonEmpty (   -- * The 'NonEmpty' singleton--  Sing((:%|)),--  -- | Though Haddock doesn't show it, the 'Sing' instance above declares-  -- constructor-  ---  -- > (:%|) :: Sing h -> Sing t -> Sing (h :| t)--  SNonEmpty,-  -- | 'SNonEmpty' is a kind-restricted synonym for 'Sing':-  -- @type SNonEmpty (a :: NonEmpty) = Sing a@+  Sing, SNonEmpty(..),    -- * Non-empty stream transformations   Map, sMap,
src/Data/Singletons/Prelude/Maybe.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, TypeFamilies,-             DataKinds, PolyKinds, UndecidableInstances, GADTs, RankNTypes #-}+             DataKinds, PolyKinds, UndecidableInstances, GADTs, RankNTypes,+             TypeApplications #-}  ----------------------------------------------------------------------------- -- |@@ -24,16 +25,7 @@  module Data.Singletons.Prelude.Maybe (   -- The 'Maybe' singleton--  Sing(SNothing, SJust),-  -- | Though Haddock doesn't show it, the 'Sing' instance above declares-  -- constructors-  ---  -- > SNothing :: Sing Nothing-  -- > SJust    :: Sing a -> Sing (Just a)--  SMaybe,-  -- | 'SBool' is a kind-restricted synonym for 'Sing': @type SMaybe (a :: Maybe k) = Sing a@+  Sing, SMaybe(..),    -- * Singletons from @Data.Maybe@   maybe_, Maybe_, sMaybe_,
src/Data/Singletons/Prelude/Monad.hs view
@@ -6,6 +6,7 @@ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -27,6 +28,7 @@ module Data.Singletons.Prelude.Monad (   PFunctor(Fmap), SFunctor(sFmap),   PMonad(..), SMonad(..), PMonadPlus(..), SMonadPlus(..),+  PMonadFail(Fail), SMonadFail(sFail),    MapM, sMapM, MapM_, sMapM_, ForM, sForM,   Sequence, sSequence, Sequence_, sSequence_,@@ -98,6 +100,7 @@ import Data.Singletons.Prelude.Functor import Data.Singletons.Prelude.Instances import Data.Singletons.Prelude.List (UnzipSym0, sUnzip, ZipWithSym0, sZipWith)+import Data.Singletons.Prelude.Monad.Fail import Data.Singletons.Prelude.Monad.Internal import Data.Singletons.Prelude.Monoid import Data.Singletons.Prelude.Num@@ -208,19 +211,21 @@    -- -| @'replicateM' n act@ performs the action @n@ times,   -- gathering the results.-  replicateM        :: (Applicative m) => Nat -> m a -> m [a]+  replicateM        :: forall m a. (Applicative m) => Nat -> m a -> m [a]   replicateM cnt0 f =       loop cnt0     where+      loop :: Nat -> m [a]       loop cnt           | cnt <= 0  = pure []           | otherwise = liftA2 (:) f (loop (cnt - 1))    -- -| Like 'replicateM', but discards the result.-  replicateM_       :: (Applicative m) => Nat -> m a -> m ()+  replicateM_       :: forall m a. (Applicative m) => Nat -> m a -> m ()   replicateM_ cnt0 f =       loop cnt0     where+      loop :: Nat -> m ()       loop cnt           | cnt <= 0  = pure ()           | otherwise = f *> loop (cnt - 1)
+ src/Data/Singletons/Prelude/Monad/Fail.hs view
@@ -0,0 +1,64 @@+{-# LANGUAGE DataKinds #-}+{-# LANGUAGE GADTs #-}+{-# LANGUAGE InstanceSigs #-}+{-# LANGUAGE PolyKinds #-}+{-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-}+{-# LANGUAGE TypeFamilies #-}+{-# LANGUAGE UndecidableInstances #-}++-----------------------------------------------------------------------------+-- |+-- Module      :  Data.Singletons.Prelude.Monad.Fail+-- Copyright   :  (C) 2019 Ryan Scott+-- License     :  BSD-style (see LICENSE)+-- Maintainer  :  Ryan Scott+-- Stability   :  experimental+-- Portability :  non-portable+--+-- Defines the promoted and singled versions of the 'MonadFail' type class.+--+----------------------------------------------------------------------------++module Data.Singletons.Prelude.Monad.Fail (+  PMonadFail(..), SMonadFail(..),++  -- * Defunctionalization symbols+  FailSym0, FailSym1+  ) where++import Data.Kind+import Data.Singletons.Prelude.Instances+import Data.Singletons.Prelude.Monad.Internal+import Data.Singletons.Single++$(singletonsOnly [d|+  -- -| When a value is bound in @do@-notation, the pattern on the left+  -- hand side of @<-@ might not match. In this case, this class+  -- provides a function to recover.+  --+  -- A 'Monad' without a 'MonadFail' instance may only be used in conjunction+  -- with pattern that always match, such as newtypes, tuples, data types with+  -- only a single data constructor, and irrefutable patterns (@~pat@).+  --+  -- Instances of 'MonadFail' should satisfy the following law: @fail s@ should+  -- be a left zero for 'Control.Monad.>>=',+  --+  -- @+  -- fail s >>= f  =  fail s+  -- @+  --+  -- If your 'Monad' is also 'Control.Monad.MonadPlus', a popular definition is+  --+  -- @+  -- fail _ = mzero+  -- @+  class Monad m => MonadFail (m :: Type -> Type) where+      fail :: String -> m a++  instance MonadFail Maybe where+      fail _ = Nothing++  instance MonadFail [] where+      fail _ = []+  |])
src/Data/Singletons/Prelude/Monad/Internal.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -43,7 +44,6 @@ import Data.Singletons.Prelude.Base import Data.Singletons.Prelude.Instances import Data.Singletons.Single-import Data.Singletons.TypeLits.Internal  {- Note [How to get the right kinds when promoting Functor and friends]@@ -275,17 +275,6 @@       return      :: a -> m a       return      = pure -      -- -| Fail with a message.  This operation is not part of the-      -- mathematical definition of a monad, but is invoked on pattern-match-      -- failure in a @do@ expression.-      ---      -- As part of the MonadFail proposal (MFP), this function is moved-      -- to its own class 'MonadFail' (see "Control.Monad.Fail" for more-      -- details). The definition here will be removed in a future-      -- release.-      fail        :: Symbol -> m a-      fail s      = error s-   {- Note [Recursive bindings for Applicative/Monad]   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ @@ -489,8 +478,6 @@        (>>) = (*>) -      fail _              = Nothing-   instance Monad NonEmpty where     (a :| as) >>= f = b :| (bs ++ bs')       where b :| bs = f a@@ -499,7 +486,6 @@    instance Monad []  where       xs >>= f = foldr ((++) . f) [] xs-      fail _ = []    instance Monad (Either e) where       Left  l >>= _ = Left l
src/Data/Singletons/Prelude/Monad/Zip.hs view
@@ -6,6 +6,7 @@ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Singletons/Prelude/Monoid.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -29,12 +30,10 @@ module Data.Singletons.Prelude.Monoid (   PMonoid(..), SMonoid(..), -  Sing(SDual, sGetDual, SAll, sGetAll, SAny, sGetAny, SSum, sGetSum,-       SProduct, sGetProduct, SFirst, sGetFirst, SLast, sGetLast),+  Sing, SDual(..), SAll(..), SAny(..),+  SSum(..), SProduct(..), SFirst(..), SLast(..),   GetDual, GetAll, GetAny, GetSum, GetProduct, GetFirst, GetLast, -  SDual, SAll, SAny, SSum, SProduct, SFirst, SLast,-   -- ** Defunctionalization symbols   MemptySym0,   MappendSym0, MappendSym1, MappendSym2,@@ -58,7 +57,7 @@ import Data.Singletons.Prelude.Num import Data.Singletons.Prelude.Ord import Data.Singletons.Prelude.Semigroup.Internal hiding-       (Sing(SFirst, SLast), SFirst, SLast,+       (SFirst, SLast,         FirstSym0, FirstSym1, FirstSym0KindInference,         LastSym0,  LastSym1,  LastSym0KindInference,         GetFirst,  GetFirstSym0, GetFirstSym1, GetFirstSym0KindInference,
src/Data/Singletons/Prelude/Num.hs view
@@ -1,6 +1,7 @@ {-# LANGUAGE TemplateHaskell, PolyKinds, DataKinds, TypeFamilies,              TypeOperators, GADTs, ScopedTypeVariables, UndecidableInstances,-             DefaultSignatures, FlexibleContexts, InstanceSigs, NoStarIsType+             DefaultSignatures, FlexibleContexts, InstanceSigs, NoStarIsType,+             TypeApplications   #-}  -----------------------------------------------------------------------------@@ -41,7 +42,7 @@ import Data.Singletons.TypeLits.Internal import Data.Singletons.Decide import qualified GHC.TypeNats as TN-import GHC.TypeNats (Nat, SomeNat(..), someNatVal)+import GHC.TypeNats (SomeNat(..), someNatVal) import Unsafe.Coerce  $(singletonsOnly [d|
src/Data/Singletons/Prelude/Ord.hs view
@@ -1,7 +1,7 @@ {-# LANGUAGE TemplateHaskell, DataKinds, PolyKinds, ScopedTypeVariables,              TypeFamilies, TypeOperators, GADTs, UndecidableInstances,              FlexibleContexts, DefaultSignatures, InstanceSigs,-             StandaloneDeriving, FlexibleInstances #-}+             StandaloneDeriving, FlexibleInstances, TypeApplications #-} {-# OPTIONS_GHC -Wno-orphans #-}  -----------------------------------------------------------------------------@@ -27,9 +27,7 @@   -- it returns its first argument.   thenCmp, ThenCmp, sThenCmp, -  Sing(SLT, SEQ, SGT, SDown),--  SOrdering, SDown,+  Sing, SOrdering(..), SDown(..),    -- ** Defunctionalization symbols   ThenCmpSym0, ThenCmpSym1, ThenCmpSym2,
src/Data/Singletons/Prelude/Semigroup.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -29,18 +30,12 @@ module Data.Singletons.Prelude.Semigroup (   PSemigroup(..), SSemigroup(..), -  Sing(SMin, sGetMin, SMax, sGetMax,-       SFirst, sGetFirst, SLast, sGetLast,-       SWrapMonoid, sUnwrapMonoid, SDual, sGetDual,-       SAll, sGetAll, SAny, sGetAny,-       SSum, sGetSum, SProduct, sGetProduct,-       SOption, sGetOption, SArg),-  GetMin, GetMax, GetFirst, GetLast, GetDual,+  Sing, SMin(..), SMax(..), SFirst(..), SLast(..),+  SWrappedMonoid(..), SDual(..), SAll(..), SAny(..),+  SSum(..), SProduct(..), SOption(..), SArg(..),+  GetMin, GetMax, GetFirst, GetLast, UnwrapMonoid, GetDual,   GetAll, GetAny, GetSum, GetProduct, GetOption, -  SMin, SMax, SFirst, SLast, SWrappedMonoid, SDual,-  SAll, SAny, SSum, SProduct, SOption, SArg,-   option_, sOption_, Option_,    -- ** Defunctionalization symbols@@ -78,7 +73,7 @@ import Data.Singletons.Prelude.Maybe import Data.Singletons.Prelude.Monad.Internal import Data.Singletons.Prelude.Monoid hiding-       (Sing(SFirst, SLast), SFirst, sGetFirst, SLast, sGetLast,+       (SFirst(..), SLast(..),         FirstSym0, FirstSym1, LastSym0, LastSym1,         GetFirst,  GetFirstSym0, GetFirstSym1,         GetLast,   GetLastSym0,  GetLastSym1)
src/Data/Singletons/Prelude/Semigroup/Internal.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -53,7 +54,7 @@ import qualified Data.Text as T import Data.Void (Void) -import GHC.TypeLits (AppendSymbol, SomeSymbol(..), someSymbolVal, Symbol)+import GHC.TypeLits (AppendSymbol, SomeSymbol(..), someSymbolVal)  import Unsafe.Coerce @@ -75,6 +76,7 @@         --         sconcat :: NonEmpty a -> a         sconcat (a :| as) = go a as where+          go :: a -> [a] -> a           go b (c:cs) = b <> go c cs           go b []     = b
src/Data/Singletons/Prelude/Show.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}
src/Data/Singletons/Prelude/Traversable.hs view
@@ -7,6 +7,7 @@ {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE StandaloneDeriving #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-} {-# LANGUAGE UndecidableInstances #-}@@ -54,7 +55,7 @@ import Data.Singletons.Internal import Data.Singletons.Prelude.Base hiding (Const, ConstSym0) import Data.Singletons.Prelude.Const-import Data.Singletons.Prelude.Foldable (PFoldable, SFoldable)+import Data.Singletons.Prelude.Foldable (SFoldable) import Data.Singletons.Prelude.Functor import Data.Singletons.Prelude.Identity import Data.Singletons.Prelude.Instances@@ -63,14 +64,16 @@ import Data.Singletons.Single  newtype StateL s a = StateL (s ~> (s, a))-data instance Sing :: forall s a. StateL s a -> Type where-  SStateL :: Sing x -> Sing ('StateL x)+data SStateL :: forall s a. StateL s a -> Type where+  SStateL :: Sing x -> SStateL ('StateL x)+type instance Sing = SStateL data StateLSym0 :: forall s a. (s ~> (s, a)) ~> StateL s a type instance Apply StateLSym0 x = 'StateL x  newtype StateR s a = StateR (s ~> (s, a))-data instance Sing :: forall s a. StateR s a -> Type where-  SStateR :: Sing x -> Sing ('StateR x)+data SStateR :: forall s a. StateR s a -> Type where+  SStateR :: Sing x -> SStateR ('StateR x)+type instance Sing = SStateR data StateRSym0 :: forall s a. (s ~> (s, a)) ~> StateR s a type instance Apply StateRSym0 x = 'StateR x
src/Data/Singletons/Prelude/Tuple.hs view
@@ -1,5 +1,6 @@ {-# LANGUAGE TemplateHaskell, ScopedTypeVariables, DataKinds, PolyKinds,-             RankNTypes, TypeFamilies, GADTs, UndecidableInstances #-}+             RankNTypes, TypeFamilies, GADTs, UndecidableInstances,+             TypeApplications #-}  ----------------------------------------------------------------------------- -- |@@ -25,8 +26,8 @@   -- * Singleton definitions   -- | See 'Data.Singletons.Prelude.Sing' for more info. -  Sing(STuple0, STuple2, STuple3, STuple4, STuple5, STuple6, STuple7),-  STuple0, STuple2, STuple3, STuple4, STuple5, STuple6, STuple7,+  Sing, STuple0(..), STuple2(..), STuple3(..),+  STuple4(..), STuple5(..), STuple6(..), STuple7(..),    -- * Singletons from @Data.Tuple@   Fst, sFst, Snd, sSnd, Curry, sCurry, Uncurry, sUncurry, Swap, sSwap,
src/Data/Singletons/Prelude/Void.hs view
@@ -4,6 +4,7 @@ {-# LANGUAGE PolyKinds #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-}+{-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE UndecidableInstances #-} -----------------------------------------------------------------------------
src/Data/Singletons/Promote.hs view
@@ -14,6 +14,10 @@ import Language.Haskell.TH hiding ( Q, cxt ) import Language.Haskell.TH.Syntax ( Quasi(..) ) import Language.Haskell.TH.Desugar+import qualified Language.Haskell.TH.Desugar.OMap.Strict as OMap+import Language.Haskell.TH.Desugar.OMap.Strict (OMap)+import qualified Language.Haskell.TH.Desugar.OSet as OSet+import Language.Haskell.TH.Desugar.OSet (OSet) import Data.Singletons.Names import Data.Singletons.Promote.Monad import Data.Singletons.Promote.Eq@@ -31,13 +35,10 @@ import Control.Applicative (Alternative(..)) import Control.Arrow (second) import Control.Monad-import Control.Monad.Trans.Class (MonadTrans(..)) import Control.Monad.Trans.Maybe import Control.Monad.Writer import qualified Data.Map.Strict as Map import Data.Map.Strict ( Map )-import qualified Data.Set as Set-import Data.Set ( Set ) import Data.Maybe import qualified GHC.LanguageExtensions.Type as LangExt @@ -141,7 +142,7 @@  -- | Produce an instance for 'PShow' from the given type promoteShowInstance :: DsMonad q => Name -> q [Dec]-promoteShowInstance = promoteInstance mkShowInstance "Show"+promoteShowInstance = promoteInstance (mkShowInstance ForPromotion) "Show"  -- | Produce an instance for @(==)@ (type-level equality) from the given type promoteEqInstance :: DsMonad q => Name -> q [Dec]@@ -163,7 +164,7 @@   cons' <- concatMapM (dsCon tvbs' data_ty) cons   let data_decl = DataDecl name tvbs' cons'   raw_inst <- mk_inst Nothing data_ty data_decl-  decs <- promoteM_ [] $ void $ promoteInstanceDec Map.empty raw_inst+  decs <- promoteM_ [] $ void $ promoteInstanceDec OMap.empty raw_inst   return $ decsToTH decs  promoteInfo :: DInfo -> PrM ()@@ -256,12 +257,12 @@   let_dec_env <- buildLetDecEnv decls   all_locals <- allLocals   let binds = [ (name, foldType (DConT sym) (map DVarT all_locals))-              | name <- Map.keys $ lde_defns let_dec_env+              | (name, _) <- OMap.assocs $ lde_defns let_dec_env               , let proName = promoteValNameLhsPrefix prefixes name                     sym = promoteTySym proName (length all_locals) ]   (decs, let_dec_env') <- letBind binds $ promoteLetDecEnv prefixes let_dec_env   emitDecs decs-  return (binds, let_dec_env' { lde_proms = Map.fromList binds })+  return (binds, let_dec_env' { lde_proms = OMap.fromList binds })  -- Promotion of data types to kinds is automatic (see "Giving Haskell a -- Promotion" paper for more details). Here we "plug into" the promotion@@ -297,8 +298,7 @@  promoteClassDec :: UClassDecl                 -> PrM AClassDecl-promoteClassDec decl@(ClassDecl { cd_cxt  = cxt-                                , cd_name = cls_name+promoteClassDec decl@(ClassDecl { cd_name = cls_name                                 , cd_tvbs = tvbs'                                 , cd_fds  = fundeps                                 , cd_lde  = lde@LetDecEnv@@ -309,31 +309,30 @@     -- a workaround for GHC Trac #12928; see Note [CUSKification]     tvbs = map cuskify tvbs'   let pClsName = promoteClassName cls_name-  pCxt <- mapM promote_superclass_pred cxt   forallBind cls_kvs_to_bind $ do-    sig_decs <- mapM (uncurry promote_sig) (Map.toList meth_sigs)-    let defaults_list  = Map.toList defaults+    sig_decs <- mapM (uncurry promote_sig) (OMap.assocs meth_sigs)+    let defaults_list  = OMap.assocs defaults         defaults_names = map fst defaults_list     (default_decs, ann_rhss, prom_rhss)-      <- mapAndUnzip3M (promoteMethod Map.empty Nothing meth_sigs) defaults_list+      <- mapAndUnzip3M (promoteMethod OMap.empty Nothing meth_sigs) defaults_list      let infix_decls' = catMaybes $ map (uncurry promoteInfixDecl)-                                 $ Map.toList infix_decls+                                 $ OMap.assocs infix_decls      -- no need to do anything to the fundeps. They work as is!-    emitDecs [DClassD pCxt pClsName tvbs fundeps+    emitDecs [DClassD [] pClsName tvbs fundeps                       (sig_decs ++ default_decs ++ infix_decls')]     let defaults_list'   = zip defaults_names ann_rhss         proms            = zip defaults_names prom_rhss         cls_kvs_to_bind' = cls_kvs_to_bind <$ meth_sigs-    return (decl { cd_lde = lde { lde_defns     = Map.fromList defaults_list'-                                , lde_proms     = Map.fromList proms+    return (decl { cd_lde = lde { lde_defns     = OMap.fromList defaults_list'+                                , lde_proms     = OMap.fromList proms                                 , lde_bound_kvs = cls_kvs_to_bind' } })   where-    cls_kvb_names, cls_tvb_names, cls_kvs_to_bind :: Set Name+    cls_kvb_names, cls_tvb_names, cls_kvs_to_bind :: OSet Name     cls_kvb_names   = foldMap (foldMap fvDType . extractTvbKind) tvbs'-    cls_tvb_names   = Set.fromList $ map extractTvbName tvbs'-    cls_kvs_to_bind = cls_kvb_names `Set.union` cls_tvb_names+    cls_tvb_names   = OSet.fromList $ map extractTvbName tvbs'+    cls_kvs_to_bind = cls_kvb_names `OSet.union` cls_tvb_names      promote_sig :: Name -> DType -> PrM DDec     promote_sig name ty = do@@ -348,19 +347,8 @@                                                  (DKindSig resK)                                                  Nothing) -    promote_superclass_pred :: DPred -> PrM DPred-    promote_superclass_pred = go-      where-      go (DForallPr {}) = fail "Cannot promote quantified constraints"-      go (DAppPr pr ty) = DAppPr <$> go pr <*> promoteType ty-      go (DSigPr pr _k) = go pr    -- just ignore the kind; it can't matter-      go (DVarPr name)  = fail $ "Cannot promote ConstraintKinds variables like "-                              ++ show name-      go (DConPr name)  = return $ DConPr (promoteClassName name)-      go DWildCardPr    = return DWildCardPr- -- returns (unpromoted method name, ALetDecRHS) pairs-promoteInstanceDec :: Map Name DType -> UInstDecl -> PrM AInstDecl+promoteInstanceDec :: OMap Name DType -> UInstDecl -> PrM AInstDecl promoteInstanceDec orig_meth_sigs                    decl@(InstDecl { id_name     = cls_name                                   , id_arg_tys  = inst_tys@@ -372,8 +360,8 @@   forallBind kvs_to_bind $ do     let subst = Map.fromList $ zip cls_tvb_names inst_kis     (meths', ann_rhss, _) <- mapAndUnzip3M (promoteMethod inst_sigs (Just subst) orig_meth_sigs) meths-    emitDecs [DInstanceD Nothing [] (foldType (DConT pClsName)-                                      inst_kis) meths']+    emitDecs [DInstanceD Nothing Nothing [] (foldType (DConT pClsName)+                                              inst_kis) meths']     return (decl { id_meths = zip (map fst meths) ann_rhss })   where     pClsName = promoteClassName cls_name@@ -430,19 +418,16 @@ that's in the type namespace) and _then_ reifies it. -} -promoteMethod :: Map Name DType -- InstanceSigs for methods+promoteMethod :: OMap Name DType -- InstanceSigs for methods               -> Maybe (Map Name DKind)                     -- ^ instantiations for class tyvars (Nothing for default decls)                     --   See Note [Promoted class method kinds]-              -> Map Name DType     -- method types+              -> OMap Name DType    -- method types               -> (Name, ULetDecRHS)               -> PrM (DDec, ALetDecRHS, DType)                  -- returns (type instance, ALetDecRHS, promoted RHS) promoteMethod inst_sigs_map m_subst orig_sigs_map (meth_name, meth_rhs) = do   (meth_arg_kis, meth_res_ki) <- lookup_meth_ty-  ((_, _, _, eqns), _defuns, ann_rhs)-    <- promoteLetDecRHS (Just (meth_arg_kis, meth_res_ki)) Map.empty Map.empty-                        noPrefix meth_name meth_rhs   meth_arg_tvs <- mapM (const $ qNewName "a") meth_arg_kis   let helperNameBase = case nameBase proName of                          first:_ | not (isHsLetter first) -> "TFHelper"@@ -462,17 +447,21 @@       -- strictly necessary, as kind inference can figure them out just as well.       family_args = map DVarT meth_arg_tvs   helperName <- newUniqueName helperNameBase+  let proHelperName = promoteValNameLhs helperName+  ((_, _, _, eqns), _defuns, ann_rhs)+    <- promoteLetDecRHS (Just (meth_arg_kis, meth_res_ki)) OMap.empty OMap.empty+                        noPrefix helperName meth_rhs   let tvbs = zipWith DKindedTV meth_arg_tvs meth_arg_kis   emitDecs [DClosedTypeFamilyD (DTypeFamilyHead-                                  helperName+                                  proHelperName                                   tvbs                                   (DKindSig meth_res_ki)                                   Nothing)                                eqns]-  emitDecsM (defunctionalize helperName Nothing tvbs (Just meth_res_ki))+  emitDecsM (defunctionalize proHelperName Nothing tvbs (Just meth_res_ki))   return ( DTySynInstD-             proName-             (DTySynEqn family_args+             (DTySynEqn Nothing+                        (foldType (DConT proName) family_args)                         (foldApply (promoteValRhs helperName) (map DVarT meth_arg_tvs)))          , ann_rhs          , DConT (promoteTySym helperName 0) )@@ -481,7 +470,7 @@      lookup_meth_ty :: PrM ([DKind], DKind)     lookup_meth_ty =-      case Map.lookup meth_name inst_sigs_map of+      case OMap.lookup meth_name inst_sigs_map of         Just ty ->           -- We have an InstanceSig. These are easy: no substitution for clas           -- variables is required at all!@@ -490,7 +479,7 @@           -- We don't have an InstanceSig, so we must compute the kind to use           -- ourselves (possibly substituting for class variables below).           (arg_kis, res_ki) <--            case Map.lookup meth_name orig_sigs_map of+            case OMap.lookup meth_name orig_sigs_map of               Nothing -> do                 mb_info <- dsReifyTypeNameInfo proName                            -- See Note [Using dsReifyTypeNameInfo when promoting instances]@@ -551,10 +540,10 @@                                      , lde_types = type_env                                      , lde_infix = fix_env }) = do   let infix_decls = catMaybes $ map (uncurry promoteInfixDecl)-                              $ Map.toList fix_env+                              $ OMap.assocs fix_env      -- promote all the declarations, producing annotated declarations-  let (names, rhss) = unzip $ Map.toList value_env+  let (names, rhss) = unzip $ OMap.assocs value_env   (payloads, defun_decss, ann_rhss)     <- fmap unzip3 $ zipWithM (promoteLetDecRHS Nothing type_env fix_env prefixes) names rhss @@ -563,11 +552,11 @@   let decs = map payload_to_dec payloads ++ infix_decls      -- build the ALetDecEnv-  let let_dec_env' = LetDecEnv { lde_defns     = Map.fromList $ zip names ann_rhss+  let let_dec_env' = LetDecEnv { lde_defns     = OMap.fromList $ zip names ann_rhss                                , lde_types     = type_env                                , lde_infix     = fix_env-                               , lde_proms     = Map.empty   -- filled in promoteLetDecs-                               , lde_bound_kvs = Map.fromList $ map (, bound_kvs) names }+                               , lde_proms     = OMap.empty  -- filled in promoteLetDecs+                               , lde_bound_kvs = OMap.fromList $ map (, bound_kvs) names }    return (decs, let_dec_env')   where@@ -583,11 +572,8 @@    -- If a name and its promoted counterpart are the same (modulo module    -- prefixes), then there's no need to promote a fixity declaration for    -- that name, since the existing fixity declaration will cover both-   -- the term- and type-level versions of that name,-   ---   -- Names that fall into this category include data constructor names-   -- and infix names, with the exceptions of (.) and (!).-   -- See Note [Special cases for (.) and (!)] in Data.Singletons.Names.+   -- the term- and type-level versions of that name. Names that fall into this+   -- category include data constructor names and infix names.  = Nothing  | otherwise  = Just $ DLetDec $ DInfixD fixity promoted_name@@ -599,8 +585,8 @@ -- an intermediate structure. Perhaps a better design is available. promoteLetDecRHS :: Maybe ([DKind], DKind)  -- the promoted type of the RHS (if known)                                             -- needed to fix #136-                 -> Map Name DType       -- local type env't-                 -> Map Name Fixity      -- local fixity env't+                 -> OMap Name DType      -- local type env't+                 -> OMap Name Fixity     -- local fixity env't                  -> (String, String)     -- let-binding prefixes                  -> Name                 -- name of the thing being promoted                  -> ULetDecRHS           -- body of the thing@@ -612,7 +598,7 @@     <- case m_rhs_ki of          Just (arg_kis, res_ki) -> return ( Just (ravelTyFun (arg_kis ++ [res_ki]))                                           , length arg_kis )-         _ |  Just ty <- Map.lookup name type_env+         _ |  Just ty <- OMap.lookup name type_env            -> do ki <- promoteType ty                  return (Just ki, countArgs ty)            |  otherwise@@ -623,18 +609,18 @@       let lde_kvs_to_bind = foldMap fvDType res_kind       (exp', ann_exp) <- forallBind lde_kvs_to_bind $ promoteExp exp       let proName = promoteValNameLhsPrefix prefixes name-          m_fixity = Map.lookup name fix_env+          m_fixity = OMap.lookup name fix_env           tvbs = map DPlainTV all_locals       defuns <- defunctionalize proName m_fixity tvbs res_kind       return ( ( proName, tvbs, res_kind-               , [DTySynEqn (map DVarT all_locals) exp'] )+               , [DTySynEqn Nothing (foldType (DConT proName) $ map DVarT all_locals) exp'] )              , defuns              , AValue (foldType (DConT proName) (map DVarT all_locals))                       num_arrows ann_exp )     _ -> do       names <- replicateM num_arrows (newUniqueName "a")-      let pats    = map DVarPa names-          newArgs = map DVarE  names+      let pats    = map DVarP names+          newArgs = map DVarE names       promoteLetDecRHS m_rhs_ki type_env fix_env prefixes name                        (UFunction [DClause pats (foldExp exp newArgs)]) @@ -642,7 +628,7 @@   numArgs <- count_args clauses   (m_argKs, m_resK, ty_num_args) <- case m_rhs_ki of     Just (arg_kis, res_ki) -> return (map Just arg_kis, Just res_ki, length arg_kis)-    _ |  Just ty <- Map.lookup name type_env+    _ |  Just ty <- OMap.lookup name type_env       -> do       -- promoteType turns arrows into TyFun. So, we unravel first to       -- avoid this behavior. Note the use of ravelTyFun in resultK@@ -654,7 +640,7 @@       |  otherwise       -> return (replicate numArgs Nothing, Nothing, numArgs)   let proName  = promoteValNameLhsPrefix prefixes name-      m_fixity = Map.lookup name fix_env+      m_fixity = OMap.lookup name fix_env   all_locals <- allLocals   let local_tvbs = map DPlainTV all_locals   tyvarNames <- mapM (const $ qNewName "a") m_argKs@@ -664,7 +650,7 @@   expClauses <- mapM (etaContractOrExpand ty_num_args numArgs) clauses   let lde_kvs_to_bind = foldMap (foldMap fvDType) m_argKs <> foldMap fvDType m_resK   (eqns, ann_clauses) <- forallBind lde_kvs_to_bind $-                         mapAndUnzipM promoteClause expClauses+                         mapAndUnzipM (promoteClause proName) expClauses   prom_fun <- lookupVarE name   return ( (proName, all_args, m_resK, eqns)          , defun_decs@@ -675,8 +661,8 @@     etaContractOrExpand ty_num_args clause_num_args (DClause pats exp)       | n >= 0 = do -- Eta-expand           names <- replicateM n (newUniqueName "a")-          let newPats = map DVarPa names-              newArgs = map DVarE  names+          let newPats = map DVarP names+              newArgs = map DVarE names           return $ DClause (pats ++ newPats) (foldExp exp newArgs)       | otherwise = do -- Eta-contract           let (clausePats, lamPats) = splitAt ty_num_args pats@@ -688,8 +674,8 @@     count_args (DClause pats _ : _) = return $ length pats     count_args _ = fail $ "Impossible! A function without clauses." -promoteClause :: DClause -> PrM (DTySynEqn, ADClause)-promoteClause (DClause pats exp) = do+promoteClause :: Name -> DClause -> PrM (DTySynEqn, ADClause)+promoteClause proName (DClause pats exp) = do   -- promoting the patterns creates variable bindings. These are passed   -- to the function promoted the RHS   ((types, pats'), prom_pat_infos) <- evalForPair $ mapAndUnzipM promotePat pats@@ -699,11 +685,11 @@                    lambdaBind new_vars $                    promoteExp exp   all_locals <- allLocals   -- these are bound *outside* of this clause-  return ( DTySynEqn (map DVarT all_locals ++ types) ty+  return ( DTySynEqn Nothing (foldType (DConT proName) $ map DVarT all_locals ++ types) ty          , ADClause new_vars pats' ann_exp ) -promoteMatch :: DMatch -> PrM (DTySynEqn, ADMatch)-promoteMatch (DMatch pat exp) = do+promoteMatch :: Name -> DMatch -> PrM (DTySynEqn, ADMatch)+promoteMatch caseTFName (DMatch pat exp) = do   -- promoting the patterns creates variable bindings. These are passed   -- to the function promoted the RHS   ((ty, pat'), prom_pat_infos) <- evalForPair $ promotePat pat@@ -713,32 +699,34 @@                     lambdaBind new_vars $                     promoteExp exp   all_locals <- allLocals-  return $ ( DTySynEqn (map DVarT all_locals ++ [ty]) rhs+  return $ ( DTySynEqn Nothing+                       (foldType (DConT caseTFName) $ map DVarT all_locals ++ [ty])+                       rhs            , ADMatch new_vars pat' ann_exp)  -- promotes a term pattern into a type pattern, accumulating bound variable names promotePat :: DPat -> QWithAux PromDPatInfos PrM (DType, ADPat)-promotePat (DLitPa lit) = (, ADLitPa lit) <$> promoteLitPat lit-promotePat (DVarPa name) = do+promotePat (DLitP lit) = (, ADLitP lit) <$> promoteLitPat lit+promotePat (DVarP name) = do       -- term vars can be symbols... type vars can't!   tyName <- mkTyName name-  tell $ PromDPatInfos [(name, tyName)] Set.empty-  return (DVarT tyName, ADVarPa name)-promotePat (DConPa name pats) = do+  tell $ PromDPatInfos [(name, tyName)] OSet.empty+  return (DVarT tyName, ADVarP name)+promotePat (DConP name pats) = do   (types, pats') <- mapAndUnzipM promotePat pats   let name' = unboxed_tuple_to_tuple name-  return (foldType (DConT name') types, ADConPa name pats')+  return (foldType (DConT name') types, ADConP name pats')   where     unboxed_tuple_to_tuple n       | Just deg <- unboxedTupleNameDegree_maybe n = tupleDataName deg       | otherwise                                  = n-promotePat (DTildePa pat) = do+promotePat (DTildeP pat) = do   qReportWarning "Lazy pattern converted into regular pattern in promotion"-  second ADTildePa <$> promotePat pat-promotePat (DBangPa pat) = do+  second ADTildeP <$> promotePat pat+promotePat (DBangP pat) = do   qReportWarning "Strict pattern converted into regular pattern in promotion"-  second ADBangPa <$> promotePat pat-promotePat (DSigPa pat ty) = do+  second ADBangP <$> promotePat pat+promotePat (DSigP pat ty) = do   -- We must maintain the invariant that any promoted pattern signature must   -- not have any wildcards in the underlying pattern.   -- See Note [Singling pattern signatures].@@ -746,8 +734,8 @@   (promoted, pat') <- promotePat wildless_pat   ki <- promoteType ty   tell $ PromDPatInfos [] (fvDType ki)-  return (DSigT promoted ki, ADSigPa promoted pat' ki)-promotePat DWildPa = return (DWildCardT, ADWildPa)+  return (DSigT promoted ki, ADSigP promoted pat' ki)+promotePat DWildP = return (DWildCardT, ADWildP)  promoteExp :: DExp -> PrM (DType, ADExp) promoteExp (DVarE name) = fmap (, ADVarE name) $ lookupVarE name@@ -775,7 +763,9 @@                                  tvbs                                  DNoSig                                  Nothing)-                               [DTySynEqn (map DVarT (all_locals ++ tyNames))+                               [DTySynEqn Nothing+                                          (foldType (DConT lambdaName) $+                                           map DVarT (all_locals ++ tyNames))                                           rhs]]   emitDecsM $ defunctionalize lambdaName Nothing tvbs Nothing   let promLambda = foldl apply (DConT (promoteTySym lambdaName 0))@@ -786,7 +776,7 @@   all_locals <- allLocals   let prom_case = foldType (DConT caseTFName) (map DVarT all_locals)   (exp', ann_exp)     <- promoteExp exp-  (eqns, ann_matches) <- mapAndUnzipM promoteMatch matches+  (eqns, ann_matches) <- mapAndUnzipM (promoteMatch caseTFName) matches   tyvarName  <- qNewName "t"   let all_args = all_locals ++ [tyvarName]       tvbs     = map DPlainTV all_args@@ -804,7 +794,7 @@ promoteExp (DSigE exp ty) = do   (exp', ann_exp) <- promoteExp exp   ty' <- promoteType ty-  return (DSigT exp' ty', ADSigE exp' ann_exp ty)+  return (DSigT exp' ty', ADSigE exp' ann_exp ty') promoteExp e@(DStaticE _) = fail ("Static expressions cannot be promoted: " ++ show e)  promoteLitExp :: Quasi q => Lit -> q DType@@ -821,7 +811,7 @@ promoteLitExp lit =   fail ("Only string and natural number literals can be promoted: " ++ show lit) -promoteLitPat :: Monad m => Lit -> m DType+promoteLitPat :: MonadFail m => Lit -> m DType promoteLitPat (IntegerL n)   | n >= 0    = return $ (DLitT (NumTyLit n))   | otherwise =
src/Data/Singletons/Promote/Defun.hs view
@@ -11,6 +11,7 @@ module Data.Singletons.Promote.Defun where  import Language.Haskell.TH.Desugar+import qualified Language.Haskell.TH.Desugar.OSet as OSet import Data.Singletons.Promote.Monad import Data.Singletons.Promote.Type import Data.Singletons.Names@@ -18,10 +19,10 @@ import Data.Singletons.Syntax import Data.Singletons.Util import Control.Monad+import Data.Foldable import qualified Data.Map.Strict as Map import Data.Map.Strict (Map) import Data.Maybe-import qualified Data.Set as Set  defunInfo :: DInfo -> PrM [DDec] defunInfo (DTyConI dec _instances) = buildDefunSyms dec@@ -41,7 +42,7 @@                -> PrM () defunTypeDecls ty_syns c_tyfams o_tyfams = do   defun_ty_syns <--    concatMapM (\(TySynDecl name tvbs) -> buildDefunSymsTySynD name tvbs) ty_syns+    concatMapM (\(TySynDecl name tvbs rhs) -> buildDefunSymsTySynD name tvbs rhs) ty_syns   defun_c_tyfams <-     concatMapM (buildDefunSymsClosedTypeFamilyD . getTypeFamilyDecl) c_tyfams   defun_o_tyfams <-@@ -55,8 +56,8 @@   buildDefunSymsClosedTypeFamilyD tf_head buildDefunSyms (DOpenTypeFamilyD tf_head) =   buildDefunSymsOpenTypeFamilyD tf_head-buildDefunSyms (DTySynD name tvbs _type) =-  buildDefunSymsTySynD name tvbs+buildDefunSyms (DTySynD name tvbs rhs) =+  buildDefunSymsTySynD name tvbs rhs buildDefunSyms (DClassD _cxt name tvbs _fundeps _members) = do   defunReifyFixity name tvbs (Just (DConT constraintName)) buildDefunSyms _ = fail $ "Defunctionalization symbols can only be built for " ++@@ -82,9 +83,18 @@       res_kind = default_kind (resultSigToMaybeKind result_sig)   defunReifyFixity name arg_tvbs res_kind -buildDefunSymsTySynD :: Name -> [DTyVarBndr] -> PrM [DDec]-buildDefunSymsTySynD name tvbs =-  defunReifyFixity name tvbs Nothing+buildDefunSymsTySynD :: Name -> [DTyVarBndr] -> DType -> PrM [DDec]+buildDefunSymsTySynD name tvbs rhs =+  defunReifyFixity name tvbs mb_res_kind+  where+    -- In order to have a CUSK, a type synonym must annotate its right-hand+    -- side with an explicit kind signature, so we can make use of this+    -- property to determine the result kind when defunctionalizing the+    -- type synonym.+    mb_res_kind :: Maybe DKind+    mb_res_kind = case rhs of+                    DSigT _ k -> Just k+                    _         -> Nothing  buildDefunSymsDataD :: [DCon] -> PrM [DDec] buildDefunSymsDataD ctors =@@ -173,10 +183,9 @@                           -- Note [Defunctionalization and dependent quantification]                           map (map_tvb_kind (substType tvb_to_type_map)) $                           reverse m_args-            tyfun_param = mk_tvb tyfun_name m_tyfun             arg_names   = map extractTvbName arg_params-            params      = arg_params ++ [tyfun_param]-            con_eq_ct   = DConPr sameKindName `DAppPr` lhs `DAppPr` rhs+            params      = arg_params ++ [DPlainTV tyfun_name]+            con_eq_ct   = DConT sameKindName `DAppT` lhs `DAppT` rhs               where                 lhs = foldType (DConT data_name) (map DVarT arg_names) `apply` (DVarT extra_name)                 rhs = foldType (DConT next_name) (map DVarT (arg_names ++ [extra_name]))@@ -193,23 +202,26 @@                                     -- If we cannot infer the return type, don't bother                                     -- trying to construct an explicit return kind.                       Just tyfun ->-                        let bound_tvs = Set.fromList (map extractTvbName arg_params) `Set.union`-                                        foldMap (foldMap fvDType) (map extractTvbKind arg_params)-                            not_bound tvb = not (extractTvbName tvb `Set.member` bound_tvs)+                        let bound_tvs = OSet.fromList (map extractTvbName arg_params)+                                        `OSet.union` foldMap (foldMap fvDType)+                                                             (map extractTvbKind arg_params)+                            not_bound tvb = not (extractTvbName tvb `OSet.member` bound_tvs)                             tvb_to_type tvb_name = fromMaybe (DVarT tvb_name) $                                                    Map.lookup tvb_name tvb_to_type_map                             -- Implements part (2)(iii) from                             -- Note [Defunctionalization and dependent quantification]-                            tyfun_tvbs = filter not_bound $         -- (2)(iii)(d)-                                         toposortTyVarsOf $         -- (2)(iii)(c)-                                         map tvb_to_type $          -- (2)(iii)(b)-                                         Set.toList $ fvDType tyfun -- (2)(iii)(a)+                            tyfun_tvbs = filter not_bound $     -- (2)(iii)(d)+                                         toposortTyVarsOf $     -- (2)(iii)(c)+                                         map tvb_to_type $      -- (2)(iii)(b)+                                         toList $ fvDType tyfun -- (2)(iii)(a)                         in (arg_params, Just (DForallT tyfun_tvbs [] tyfun))             app_data_ty = foldTypeTvbs (DConT data_name) m_args-            app_eqn     = DTySynEqn [app_data_ty, DVarT tyfun_name]+            app_eqn     = DTySynEqn Nothing+                                    (DConT applyName `DAppT` app_data_ty+                                                     `DAppT` DVarT tyfun_name)                                     (mk_rhs (m_args ++ [DPlainTV tyfun_name]))-            app_decl    = DTySynInstD applyName app_eqn-            suppress    = DInstanceD Nothing []+            app_decl    = DTySynInstD app_eqn+            suppress    = DInstanceD Nothing Nothing []                             (DConT suppressClassName `DAppT` app_data_ty)                             [DLetDec $ DFunD suppressMethodName                                              [DClause []@@ -234,10 +246,6 @@   other_decs <- go (num_args - 1) (reverse m_arg_tvbs) m_res_kind mk_rhs   return $ sat_dec : other_decs   where-    mk_tvb :: Name -> Maybe DKind -> DTyVarBndr-    mk_tvb tvb_name Nothing  = DPlainTV tvb_name-    mk_tvb tvb_name (Just k) = DKindedTV tvb_name k-     eta_expand :: [DTyVarBndr] -> Maybe DKind -> PrM ([DTyVarBndr], Maybe DKind)     eta_expand m_arg_tvbs Nothing = pure (m_arg_tvbs, Nothing)     eta_expand m_arg_tvbs (Just res_kind) = do
src/Data/Singletons/Promote/Eq.hs view
@@ -22,9 +22,9 @@   helperName <- newUniqueName "Equals"   aName <- qNewName "a"   bName <- qNewName "b"-  true_branches <- mapM mk_branch cons-  let null_branch  = catch_all_case trueName-      false_branch = catch_all_case falseName+  true_branches <- mapM (mk_branch helperName) cons+  let null_branch  = catch_all_case helperName trueName+      false_branch = catch_all_case helperName falseName       branches | null cons = [null_branch]                | otherwise = true_branches ++ [false_branch]       closedFam = DClosedTypeFamilyD (DTypeFamilyHead helperName@@ -37,16 +37,17 @@                                                       (DKindSig boolKi)                                                       Nothing)                                      branches-      eqInst = DTySynInstD tyEqName (DTySynEqn [DVarT aName, DVarT bName]-                                             (foldType (DConT helperName)-                                                       [DVarT aName, DVarT bName]))-      inst = DInstanceD Nothing [] ((DConT $ promoteClassName eqName) `DAppT`-                                    kind) [eqInst]+      eqInst = DTySynInstD $+               DTySynEqn Nothing+                         (DConT tyEqName `DAppT` DVarT aName `DAppT` DVarT bName)+                         (foldType (DConT helperName) [DVarT aName, DVarT bName])+      inst = DInstanceD Nothing Nothing [] ((DConT $ promoteClassName eqName) `DAppT`+                                            kind) [eqInst]    return [closedFam, inst] -  where mk_branch :: Quasi q => DCon -> q DTySynEqn-        mk_branch con = do+  where mk_branch :: Quasi q => Name -> DCon -> q DTySynEqn+        mk_branch helper_name con = do           let (name, numArgs) = extractNameArgs con           lnames <- replicateM numArgs (qNewName "a")           rnames <- replicateM numArgs (qNewName "b")@@ -56,11 +57,16 @@               rtype = foldType (DConT name) rvars               results = zipWith (\l r -> foldType (DConT tyEqName) [l, r]) lvars rvars               result = tyAll results-          return $ DTySynEqn [ltype, rtype] result+          return $ DTySynEqn Nothing+                             (DConT helper_name `DAppT` ltype `DAppT` rtype)+                             result -        catch_all_case :: Name -> DTySynEqn-        catch_all_case returned_val_name =-          DTySynEqn [DSigT DWildCardT kind, DSigT DWildCardT kind]+        catch_all_case :: Name -> Name -> DTySynEqn+        catch_all_case helper_name returned_val_name =+          DTySynEqn Nothing+                    (DConT helper_name+                       `DAppT` DSigT DWildCardT kind+                       `DAppT` DSigT DWildCardT kind)                     (promoteValRhs returned_val_name)          tyAll :: [DType] -> DType -- "all" at the type level
src/Data/Singletons/Promote/Monad.hs view
@@ -9,8 +9,8 @@ of DDec, and is wrapped around a Q. -} -{-# LANGUAGE GeneralizedNewtypeDeriving, StandaloneDeriving,-             FlexibleContexts, TypeFamilies, KindSignatures #-}+{-# LANGUAGE GeneralizedNewtypeDeriving, FlexibleContexts,+             TypeFamilies, KindSignatures #-}  module Data.Singletons.Promote.Monad (   PrM, promoteM, promoteM_, promoteMDecs, VarPromotions,@@ -20,30 +20,29 @@  import Control.Monad.Reader import Control.Monad.Writer-import qualified Data.Map.Strict as Map-import Data.Map.Strict ( Map )-import qualified Data.Set as Set-import Data.Set ( Set ) import Language.Haskell.TH.Syntax hiding ( lift ) import Language.Haskell.TH.Desugar+import qualified Language.Haskell.TH.Desugar.OMap.Strict as OMap+import Language.Haskell.TH.Desugar.OMap.Strict (OMap)+import qualified Language.Haskell.TH.Desugar.OSet as OSet+import Language.Haskell.TH.Desugar.OSet (OSet) import Data.Singletons.Names import Data.Singletons.Syntax-import Control.Monad.Fail ( MonadFail ) -type LetExpansions = Map Name DType  -- from **term-level** name+type LetExpansions = OMap Name DType  -- from **term-level** name  -- environment during promotion data PrEnv =-  PrEnv { pr_lambda_bound :: Map Name Name+  PrEnv { pr_lambda_bound :: OMap Name Name         , pr_let_bound    :: LetExpansions-        , pr_forall_bound :: Set Name -- See Note [Explicitly quantifying kinds variables]+        , pr_forall_bound :: OSet Name -- See Note [Explicitly quantifying kinds variables]         , pr_local_decls  :: [Dec]         }  emptyPrEnv :: PrEnv-emptyPrEnv = PrEnv { pr_lambda_bound = Map.empty-                   , pr_let_bound    = Map.empty-                   , pr_forall_bound = Set.empty+emptyPrEnv = PrEnv { pr_lambda_bound = OMap.empty+                   , pr_let_bound    = OMap.empty+                   , pr_forall_bound = OSet.empty                    , pr_local_decls  = [] }  -- the promotion monad@@ -58,12 +57,12 @@ -- return *type-level* names allLocals :: MonadReader PrEnv m => m [Name] allLocals = do-  lambdas <- asks (Map.toList . pr_lambda_bound)+  lambdas <- asks (OMap.assocs . pr_lambda_bound)   lets    <- asks pr_let_bound     -- filter out shadowed variables!   return [ typeName          | (termName, typeName) <- lambdas-         , case Map.lookup termName lets of+         , case OMap.lookup termName lets of              Just (DVarT typeName') | typeName' == typeName -> True              _                                              -> False ] @@ -81,33 +80,33 @@ lambdaBind binds = local add_binds   where add_binds env@(PrEnv { pr_lambda_bound = lambdas                              , pr_let_bound    = lets }) =-          let new_lets = Map.fromList [ (tmN, DVarT tyN) | (tmN, tyN) <- binds ] in-          env { pr_lambda_bound = Map.union (Map.fromList binds) lambdas-              , pr_let_bound    = Map.union new_lets lets }+          let new_lets = OMap.fromList [ (tmN, DVarT tyN) | (tmN, tyN) <- binds ] in+          env { pr_lambda_bound = OMap.fromList binds `OMap.union` lambdas+              , pr_let_bound    = new_lets            `OMap.union` lets }  type LetBind = (Name, DType) letBind :: [LetBind] -> PrM a -> PrM a letBind binds = local add_binds   where add_binds env@(PrEnv { pr_let_bound = lets }) =-          env { pr_let_bound = Map.union (Map.fromList binds) lets }+          env { pr_let_bound = OMap.fromList binds `OMap.union` lets }  lookupVarE :: Name -> PrM DType lookupVarE n = do   lets <- asks pr_let_bound-  case Map.lookup n lets of+  case OMap.lookup n lets of     Just ty -> return ty     Nothing -> return $ promoteValRhs n  -- Add to the set of bound kind variables currently in scope. -- See Note [Explicitly binding kind variables]-forallBind :: Set Name -> PrM a -> PrM a+forallBind :: OSet Name -> PrM a -> PrM a forallBind kvs1 =   local (\env@(PrEnv { pr_forall_bound = kvs2 }) ->-    env { pr_forall_bound = kvs1 `Set.union` kvs2 })+    env { pr_forall_bound = kvs1 `OSet.union` kvs2 })  -- Look up the set of bound kind variables currently in scope. -- See Note [Explicitly binding kind variables]-allBoundKindVars :: PrM (Set Name)+allBoundKindVars :: PrM (OSet Name) allBoundKindVars = asks pr_forall_bound  promoteM :: DsMonad q => [Dec] -> PrM a -> q (a, [DDec])
src/Data/Singletons/Promote/Type.hs view
@@ -6,19 +6,20 @@ This file implements promotion of types into kinds. -} -module Data.Singletons.Promote.Type ( promoteType, promoteUnraveled ) where+module Data.Singletons.Promote.Type+  ( promoteType, promoteTypeArg, promoteUnraveled+  ) where  import Language.Haskell.TH.Desugar import Data.Singletons.Names-import Data.Singletons.Util import Language.Haskell.TH  -- the only monadic thing we do here is fail. This allows the function -- to be used from the Singletons module-promoteType :: Monad m => DType -> m DKind+promoteType :: MonadFail m => DType -> m DKind promoteType = go []   where-    go :: Monad m => [DKind] -> DType -> m DKind+    go :: MonadFail m => [DTypeArg] -> DType -> m DKind     -- We don't need to worry about constraints: they are used to express     -- static guarantees at runtime. But, because we don't need to do     -- anything special to keep static guarantees at compile time, we don't@@ -28,34 +29,42 @@       fail "Cannot promote types of rank above 1."     go args     (DAppT t1 t2) = do       k2 <- go [] t2-      go (k2 : args) t1+      go (DTANormal k2 : args) t1        -- NB: This next case means that promoting something like        --   (((->) a) :: Type -> Type) b        -- will fail because the pattern below won't recognize the        -- arrow to turn it into a TyFun. But I'm not terribly        -- bothered by this, and it would be annoying to fix. Wait        -- for someone to report.+    go args     (DAppKindT ty ki) = do+      ki' <- go [] ki+      go (DTyArg ki' : args) ty     go args     (DSigT ty ki) = do       ty' <- go [] ty       -- No need to promote 'ki' - it is already a kind.-      return $ foldType (DSigT ty' ki) args-    go args     (DVarT name) = return $ foldType (DVarT name) args+      return $ applyDType (DSigT ty' ki) args+    go args     (DVarT name) = return $ applyDType (DVarT name) args     go []       (DConT name)       | name == typeRepName               = return $ DConT typeKindName       | nameBase name == nameBase repName = return $ DConT typeKindName     go args     (DConT name)       | Just n <- unboxedTupleNameDegree_maybe name-      = return $ foldType (DConT (tupleTypeName n)) args+      = return $ applyDType (DConT (tupleTypeName n)) args       | otherwise-      = return $ foldType (DConT name) args-    go [k1, k2] DArrowT = return $ DConT tyFunArrowName `DAppT` k1 `DAppT` k2+      = return $ applyDType (DConT name) args+    go [DTANormal k1, DTANormal k2] DArrowT+      = return $ DConT tyFunArrowName `DAppT` k1 `DAppT` k2     go _        ty@DLitT{} = pure ty      go args     hd = fail $ "Illegal Haskell construct encountered:\n" ++                             "headed by: " ++ show hd ++ "\n" ++                             "applied to: " ++ show args -promoteUnraveled :: Monad m => DType -> m ([DKind], DKind)+promoteTypeArg :: MonadFail m => DTypeArg -> m DTypeArg+promoteTypeArg (DTANormal t) = DTANormal <$> promoteType t+promoteTypeArg ta@(DTyArg _) = pure ta -- Kinds are already promoted++promoteUnraveled :: MonadFail m => DType -> m ([DKind], DKind) promoteUnraveled ty = do   arg_kis <- mapM promoteType arg_tys   res_ki  <- promoteType res_ty
src/Data/Singletons/ShowSing.hs view
@@ -1,11 +1,12 @@-{-# LANGUAGE ConstraintKinds #-} {-# LANGUAGE DataKinds #-}+{-# LANGUAGE EmptyCase #-}+{-# LANGUAGE FlexibleContexts #-} {-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-} {-# LANGUAGE PolyKinds #-} {-# LANGUAGE QuantifiedConstraints #-} {-# LANGUAGE RankNTypes #-}-{-# LANGUAGE StandaloneDeriving #-}+{-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE UndecidableInstances #-} {-# OPTIONS_GHC -Wno-orphans #-}@@ -26,7 +27,10 @@  module Data.Singletons.ShowSing (   -- * The 'ShowSing' type-  ShowSing+  ShowSing,++  -- * Internal utilities+  ShowSing'   ) where  import Data.Singletons.Internal@@ -48,35 +52,50 @@ -- an instance with the following shape: -- -- @--- deriving instance ??? => Show (Sing (x :: [k]))+-- instance ??? => 'Show' ('SList' (z :: [k])) where+--   showsPrec p 'SNil' = showString \"SNil\"+--   showsPrec p ('SCons' sx sxs) =+--     showParen (p > 10) $ showString \"SCons \" . showsPrec 11 sx+--                        . showSpace . showsPrec 11 sxs -- @ -- -- To figure out what should go in place of @???@, observe that we require the -- type of each field to also be 'Show' instances. In other words, we need--- something like @(Show (Sing (a :: k)))@. But this isn't quite right, as the+-- something like @('Show' ('Sing' (a :: k)))@. But this isn't quite right, as the -- type variable @a@ doesn't appear in the instance head. In fact, this @a@ -- type is really referring to an existentially quantified type variable in the -- 'SCons' constructor, so it doesn't make sense to try and use it like this. -- -- Luckily, the @QuantifiedConstraints@ language extension provides a solution -- to this problem. This lets you write a context of the form--- @(forall a. Show (Sing (a :: k)))@, which demands that there be an instance--- for @Show (Sing (a :: k))@ that is parametric in the use of @a@. Thus, our--- final instance looks like:+-- @(forall a. 'Show' ('Sing' (a :: k)))@, which demands that there be an instance+-- for @'Show' ('Sing' (a :: k))@ that is parametric in the use of @a@.+-- This lets us write something closer to this: -- -- @--- deriving instance (forall a. Show (Sing (a :: k))) => Show (Sing (x :: [k]))+-- instance (forall a. 'Show' ('Sing' (a :: k))) => 'SList' ('Sing' (z :: [k])) where ... -- @ ----- Because that quantified constraint is somewhat lengthy, we provide the--- 'ShowSing' class synonym as a convenient shorthand. Thus, the above instance--- is equivalent to:+-- The 'ShowSing' class is a thin wrapper around+-- @(forall a. 'Show' ('Sing' (a :: k)))@. With 'ShowSing', our final instance+-- declaration becomes this: -- -- @--- deriving instance ShowSing k => Show (Sing (x :: [k]))+-- instance 'ShowSing' k => 'Show' ('SList' (z :: [k])) where+--   showsPrec p 'SNil' = showString \"SNil\"+--   showsPrec p ('SCons' (sx :: 'Sing' x) (sxs :: 'Sing' xs)) =+--     (showParen (p > 10) $ showString \"SCons \" . showsPrec 11 sx+--                         . showSpace . showsPrec 11 sxs)+--       :: (ShowSing' x, ShowSing' xs) => ShowS -- @ ----- When singling a derived 'Show' instance, @singletons@ will also derive+-- (Note that the actual definition of 'ShowSing' is slightly more complicated+-- than what this documentation might suggest. For the full story, as well as+-- an explanation of why we need an explicit+-- @(ShowSing' x, ShowSing' xs) => ShowS@ signature at the end,+-- refer to the documentation for `ShowSing'`.)+--+-- When singling a derived 'Show' instance, @singletons@ will also generate -- a 'Show' instance for the corresponding singleton type using 'ShowSing'. -- In other words, if you give @singletons@ a derived 'Show' instance, then -- you'll receive the following in return:@@ -86,21 +105,106 @@ -- * A 'Show' instance for the singleton type -- -- What a bargain!-class    (forall (z :: k). Show (Sing z)) => ShowSing k-instance (forall (z :: k). Show (Sing z)) => ShowSing k +-- One might wonder we we simply don't define ShowSing as+-- @type ShowSing k = (forall (z :: k). ShowSing' z)@ instead of going the+-- extra mile to define it as a class.+-- See Note [Define ShowSing as a class, not a type synonym] for an explanation.+class    (forall (z :: k). ShowSing' z) => ShowSing k+instance (forall (z :: k). ShowSing' z) => ShowSing k++-- | The workhorse that powers 'ShowSing'. The only reason that `ShowSing'`+-- exists is to work around GHC's inability to put type families in the head+-- of a quantified constraint (see+-- <https://gitlab.haskell.org/ghc/ghc/issues/14860 this GHC issue> for more+-- details on this point). In other words, GHC will not let you define+-- 'ShowSing' like so:+--+-- @+-- class (forall (z :: k). 'Show' ('Sing' z)) => 'ShowSing' k+-- @+--+-- By replacing @'Show' ('Sing' z)@ with @ShowSing' z@, we are able to avoid+-- this restriction for the most part. There is one major downside to using+-- @ShowSing'@, however: deriving 'Show' instances for singleton types does+-- not work out of the box. In other words, if you try to do this:+--+-- @+-- deriving instance 'ShowSing' k => 'Show' ('SList' (z :: [k]))+-- @+--+-- Then GHC will complain to the effect that it could not deduce a+-- @'Show' ('Sing' x)@ constraint. This is due to+-- <https://gitlab.haskell.org/ghc/ghc/issues/16365 another unfortunate GHC bug>+-- that prevents GHC from realizing that @'ShowSing' k@ implies+-- @'Show' ('Sing' (x :: k))@. The workaround is to force GHC to come to its+-- senses by using an explicit type signature:+--+-- @+-- instance 'ShowSing' k => 'Show' ('SList' (z :: [k])) where+--   showsPrec p 'SNil' = showString \"SNil\"+--   showsPrec p ('SCons' (sx :: 'Sing' x) (sxs :: 'Sing' xs)) =+--     (showParen (p > 10) $ showString \"SCons \" . showsPrec 11 sx+--                         . showSpace . showsPrec 11 sxs)+--       :: (ShowSing' x, ShowSing' xs) => ShowS+-- @+--+-- The use of @ShowSing' x@ in the signature is sufficient to make the+-- constraint solver connect the dots between @'ShowSing' k@ and+-- @'Show' ('Sing' (x :: k))@. (The @ShowSing' xs@ constraint is not strictly+-- necessary, but it is shown here since that is in fact the code that+-- @singletons@ will generate for this instance.)+--+-- Because @deriving 'Show'@ will not insert these explicit signatures for us,+-- it is not possible to derive 'Show' instances for singleton types.+-- Thankfully, @singletons@' Template Haskell machinery can do this manual+-- gruntwork for us 99% of the time, but if you ever find yourself in a+-- situation where you must define a 'Show' instance for a singleton type by+-- hand, this is important to keep in mind.+--+-- Note that there is one potential future direction that might alleviate this+-- pain. We could define `ShowSing'` like this instead:+--+-- @+-- class (forall sing. sing ~ 'Sing' => 'Show' (sing z)) => ShowSing' z+-- instance 'Show' ('Sing' z) => ShowSing' z+-- @+--+-- For many examples, this lets you just derive 'Show' instances for singleton+-- types like you would expect. Alas, this topples over on @Bar@ in the+-- following example:+--+-- @+-- newtype Foo a = MkFoo a+-- data SFoo :: forall a. Foo a -> Type where+--   SMkFoo :: Sing x -> SFoo (MkFoo x)+-- type instance Sing = SFoo+-- deriving instance ShowSing a => Show (SFoo (z :: Foo a))+--+-- newtype Bar a = MkBar (Foo a)+-- data SBar :: forall a. Bar a -> Type where+--   SMkBar :: Sing x -> SBar (MkBar x)+-- type instance Sing = SBar+-- deriving instance ShowSing (Foo a) => Show (SBar (z :: Bar a))+-- @+--+-- This fails because+-- of—you guessed it—<https://gitlab.haskell.org/ghc/ghc/issues/16502 another GHC bug>.+-- Bummer. Unless that bug were to be fixed, the current definition of+-- `ShowSing'` is the best that we can do.+class    Show (Sing z) => ShowSing' z+instance Show (Sing z) => ShowSing' z+ {- Note [Define ShowSing as a class, not a type synonym] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-In an ideal world, we would simply define ShowSing as an ordinary type synonym,-like this:+In an ideal world, we would simply define ShowSing like this: -  type ShowSing k = (forall (z :: k). Show (Sing z) :: Constraint)+  type ShowSing k = (forall (z :: k). ShowSing' z) :: Constraint) -In fact, I used to assume that we lived in an ideal world, so I defined-ShowSing as a type synonym in version 2.5 of this library. However, I realized-some time after 2.5's release that the world is far from ideal, unfortunately,-and that this approach is unfeasible at the time being due to GHC Trac #15888.+In fact, I used to define ShowSing in a manner similar to this in version 2.5+of singletons. However, I realized some time after 2.5's release that the+this encoding is unfeasible at the time being due to GHC Trac #15888.  To be more precise, the exact issue involves an infelicity in the way QuantifiedConstraints interacts with recursive type class instances.@@ -130,18 +234,18 @@ To see why this happens, observe what goes on if we expand the occurrences of the ShowSing type synonym in the generated instances: -  deriving instance (forall z. Show (Sing (z :: Y a))) => Show (Sing (z :: X a))-  deriving instance (forall z. Show (Sing (z :: X a))) => Show (Sing (z :: Y a))+  deriving instance (forall z. ShowSing' (z :: Y a)) => Show (Sing (z :: X a))+  deriving instance (forall z. ShowSing' (z :: X a)) => Show (Sing (z :: Y a))  Due to the way QuantifiedConstraints currently works (as surmised in Trac-#15888), when GHC has a Wanted `Show (Sing X1 :: X Bool)` constraint, it+#15888), when GHC has a Wanted `ShowSing' (X1 :: X Bool)` constraint, it chooses the appropriate instance and emits a Wanted-`forall z. Show (Sing (z :: Y Bool))` constraint (from the instance context).+`forall z. ShowSing' (z :: Y Bool)` constraint (from the instance context). GHC skolemizes the `z` to `z1` and tries to solve a Wanted-`Show (Sing (z1 :: Y Bool))` constraint. GHC chooses the appropriate instance-and emits a Wanted `forall z. Show (Sing (z :: X Bool))` constraint. GHC+`ShowSing' (z1 :: Y Bool)` constraint. GHC chooses the appropriate instance+and emits a Wanted `forall z. ShowSing' (z :: X Bool)` constraint. GHC skolemizes the `z` to `z2` and tries to solve a Wanted-`Show (Sing (z2 :: X Bool))` constraint... we repeat the process and find+`ShowSing' (z2 :: X Bool)` constraint... we repeat the process and find ourselves in an infinite loop that eventually overflows the reduction stack. Eep. @@ -162,6 +266,20 @@ Given the two options, (2) is by far the easier option, so that is what we ultimately went with. -}++------------------------------------------------------------+-- (S)WrappedSing instances+------------------------------------------------------------++instance ShowSing k => Show (WrappedSing (a :: k)) where+  showsPrec p (WrapSing s) = showParen (p >= 11) $+    showString "WrapSing {unwrapSing = " . showsPrec 0 s . showChar '}'+      :: ShowSing' a => ShowS++instance ShowSing k => Show (SWrappedSing (ws :: WrappedSing (a :: k))) where+  showsPrec p (SWrapSing s) = showParen (p >= 11) $+    showString "SWrapSing {sUnwrapSing = " . showsPrec 0 s . showChar '}'+      :: ShowSing' a => ShowS  ------------------------------------------------------------ -- TypeLits instances
src/Data/Singletons/Sigma.hs view
@@ -1,13 +1,18 @@ {-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE DataKinds #-}+{-# LANGUAGE FlexibleContexts #-}+{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE GADTs #-}+{-# LANGUAGE ImpredicativeTypes #-} -- See Note [Impredicative Σ?]+{-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE PolyKinds #-}+{-# LANGUAGE QuantifiedConstraints #-} {-# LANGUAGE RankNTypes #-} {-# LANGUAGE ScopedTypeVariables #-}-{-# LANGUAGE TemplateHaskell #-} {-# LANGUAGE TypeApplications #-} {-# LANGUAGE TypeFamilies #-} {-# LANGUAGE TypeOperators #-}+{-# LANGUAGE UndecidableInstances #-}  ----------------------------------------------------------------------------- -- |@@ -23,40 +28,96 @@ ----------------------------------------------------------------------------  module Data.Singletons.Sigma-    ( Sigma(..), Σ+    ( -- * The 'Sigma' type+      Sigma(..), Σ+    , Sing, SSigma(..), SΣ++      -- * Operations over 'Sigma'+    , fstSigma, FstSigma, sndSigma, SndSigma     , projSigma1, projSigma2     , mapSigma, zipSigma+    , currySigma, uncurrySigma -      -- * Defunctionalization symbols-    , ΣSym0, ΣSym1, ΣSym2+      -- * Internal utilities+      -- $internalutilities+    , ShowApply,  ShowSingApply+    , ShowApply', ShowSingApply'     ) where  import Data.Kind (Type) import Data.Singletons.Internal-import Data.Singletons.Promote+import Data.Singletons.ShowSing  -- | A dependent pair. data Sigma (s :: Type) :: (s ~> Type) -> Type where   (:&:) :: forall s t fst. Sing (fst :: s) -> t @@ fst -> Sigma s t infixr 4 :&:+instance (ShowSing s, ShowApply t) => Show (Sigma s t) where+  showsPrec p ((a :: Sing (fst :: s)) :&: b) = showParen (p >= 5) $+    showsPrec 5 a . showString " :&: " . showsPrec 5 b+      :: (ShowSing' fst, ShowApply' t fst) => ShowS  -- | Unicode shorthand for 'Sigma'.-type Σ (s :: Type) (t :: s ~> Type) = Sigma s t+type Σ = Sigma +{-+Note [Impredicative Σ?]+~~~~~~~~~~~~~~~~~~~~~~~+The definition of Σ currently will not typecheck without the use of+ImpredicativeTypes. There isn't a fundamental reason that this should be the+case, and the only reason that GHC currently requires this is due to Trac+#13408. If someone ever fixes that bug, we could remove the use of+ImpredicativeTypes.+-}++-- | The singleton type for 'Sigma'.+data SSigma :: forall s (t :: s ~> Type). Sigma s t -> Type where+  (:%&:) :: forall s t (fst :: s) (sfst :: Sing fst) (snd :: t @@ fst).+            Sing ('WrapSing sfst) -> Sing snd -> SSigma (sfst ':&: snd :: Sigma s t)+infixr 4 :%&:++type instance Sing = SSigma+instance forall s (t :: s ~> Type) (sig :: Sigma s t).+         (ShowSing s, ShowSingApply t)+      => Show (SSigma sig) where+  showsPrec p ((sa :: Sing ('WrapSing (sfst :: Sing fst))) :%&: (sb :: Sing snd)) =+    showParen (p >= 5) $+      showsPrec 5 sa . showString " :&: " . showsPrec 5 sb+        :: (ShowSing' fst, ShowSingApply' t fst snd) => ShowS++instance forall s t (fst :: s) (a :: Sing fst) (b :: t @@ fst).+       (SingI fst, SingI b)+    => SingI (a ':&: b :: Sigma s t) where+  sing = sing :%&: sing++-- | Unicode shorthand for 'SSigma'.+type SΣ = SSigma+ -- | Project the first element out of a dependent pair.-projSigma1 :: forall s t. SingKind s => Sigma s t -> Demote s-projSigma1 (a :&: _) = fromSing a+fstSigma :: forall s t. SingKind s => Sigma s t -> Demote s+fstSigma (a :&: _) = fromSing a +-- | Project the first element out of a dependent pair.+type family FstSigma (sig :: Sigma s t) :: s where+  FstSigma ((_ :: Sing fst) ':&: _) = fst+ -- | Project the second element out of a dependent pair.------ In an ideal setting, the type of 'projSigma2' would be closer to:------ @--- 'projSigma2' :: 'Sing' (sig :: 'Sigma' s t) -> t @@ ProjSigma1 sig--- @------ But promoting 'projSigma1' to a type family is not a simple task. Instead,--- we do the next-best thing, which is to use Church-style elimination.+sndSigma :: forall s t (sig :: Sigma s t).+            SingKind (t @@ FstSigma sig)+         => SSigma sig -> Demote (t @@ FstSigma sig)+sndSigma (_ :%&: b) = fromSing b++-- | Project the second element out of a dependent pair.+type family SndSigma (sig :: Sigma s t) :: t @@ FstSigma sig where+  SndSigma (_ ':&: b) = b++-- | Project the first element out of a dependent pair using+-- continuation-passing style.+projSigma1 :: (forall (fst :: s). Sing fst -> r) -> Sigma s t -> r+projSigma1 f (a :&: _) = f a++-- | Project the second element out of a dependent pair using+-- continuation-passing style. projSigma2 :: forall s t r. (forall (fst :: s). t @@ fst -> r) -> Sigma s t -> r projSigma2 f ((_ :: Sing (fst :: s)) :&: b) = f @fst b @@ -72,4 +133,57 @@ zipSigma f g ((a :: Sing (fstA :: a)) :&: p) ((b :: Sing (fstB :: b)) :&: q) =   (f @@ a @@ b) :&: (g @fstA @fstB p q) -$(genDefunSymbols [''Σ])+-- | Convert an uncurried function on 'Sigma' to a curried one.+--+-- Together, 'currySigma' and 'uncurrySigma' witness an isomorphism such that+-- the following identities hold:+--+-- @+-- id1 :: forall a (b :: a ~> Type) (c :: 'Sigma' a b ~> Type).+--        (forall (p :: Sigma a b). 'SSigma' p -> c @@ p)+--     -> (forall (p :: Sigma a b). 'SSigma' p -> c @@ p)+-- id1 f = 'uncurrySigma' @a @b @c ('currySigma' @a @b @c f)+--+-- id2 :: forall a (b :: a ~> Type) (c :: 'Sigma' a b ~> Type).+--        (forall (x :: a) (sx :: Sing x) (y :: b @@ x). Sing ('WrapSing' sx) -> Sing y -> c @@ (sx :&: y))+--     -> (forall (x :: a) (sx :: Sing x) (y :: b @@ x). Sing ('WrapSing' sx) -> Sing y -> c @@ (sx :&: y))+-- id2 f = 'currySigma' @a @b @c ('uncurrySigma' @a @b @c f)+-- @+currySigma :: forall a (b :: a ~> Type) (c :: Sigma a b ~> Type).+              (forall (p :: Sigma a b). SSigma p -> c @@ p)+           -> (forall (x :: a) (sx :: Sing x) (y :: b @@ x).+                 Sing ('WrapSing sx) -> Sing y -> c @@ (sx ':&: y))+currySigma f x y = f (x :%&: y)++-- | Convert a curried function on 'Sigma' to an uncurried one.+--+-- Together, 'currySigma' and 'uncurrySigma' witness an isomorphism.+-- (Refer to the documentation for 'currySigma' for more details.)+uncurrySigma :: forall a (b :: a ~> Type) (c :: Sigma a b ~> Type).+                (forall (x :: a) (sx :: Sing x) (y :: b @@ x).+                   Sing ('WrapSing sx) -> Sing y -> c @@ (sx ':&: y))+             -> (forall (p :: Sigma a b). SSigma p -> c @@ p)+uncurrySigma f (x :%&: y) = f x y++------------------------------------------------------------+-- Internal utilities+------------------------------------------------------------++{- $internal-utilities++See the documentation in "Data.Singletons.ShowSing"—in particular, the+Haddocks for 'ShowSing' and `ShowSing'`—for an explanation for why these+classes exist.+-}++class    (forall (x :: a). ShowApply' f x) => ShowApply (f :: a ~> Type)+instance (forall (x :: a). ShowApply' f x) => ShowApply (f :: a ~> Type)++class    Show (Apply f x) => ShowApply' (f :: a ~> Type) (x :: a)+instance Show (Apply f x) => ShowApply' (f :: a ~> Type) (x :: a)++class    (forall (x :: a) (z :: Apply f x). ShowSingApply' f x z) => ShowSingApply (f :: a ~> Type)+instance (forall (x :: a) (z :: Apply f x). ShowSingApply' f x z) => ShowSingApply (f :: a ~> Type)++class    Show (Sing z) => ShowSingApply' (f :: a ~> Type) (x :: a) (z :: Apply f x)+instance Show (Sing z) => ShowSingApply' (f :: a ~> Type) (x :: a) (z :: Apply f x)
src/Data/Singletons/Single.hs view
@@ -13,7 +13,6 @@ import Prelude hiding ( exp ) import Language.Haskell.TH hiding ( cxt ) import Language.Haskell.TH.Syntax (NameSpace(..), Quasi(..))-import Data.Singletons.Deriving.Infer import Data.Singletons.Deriving.Ord import Data.Singletons.Deriving.Bounded import Data.Singletons.Deriving.Enum@@ -34,11 +33,14 @@ import Data.Singletons.Syntax import Data.Singletons.Partition import Language.Haskell.TH.Desugar+import qualified Language.Haskell.TH.Desugar.OMap.Strict as OMap+import Language.Haskell.TH.Desugar.OMap.Strict (OMap)+import qualified Language.Haskell.TH.Desugar.OSet as OSet+import Language.Haskell.TH.Desugar.OSet (OSet) import qualified Data.Map.Strict as Map import Data.Map.Strict ( Map ) import Data.Maybe import qualified Data.Set as Set-import Data.Set ( Set ) import Control.Monad import Data.List import qualified GHC.LanguageExtensions.Type as LangExt@@ -128,11 +130,13 @@ singEqInstanceOnly :: DsMonad q => Name -> q [Dec] singEqInstanceOnly name = singEqualityInstance sEqClassDesc name --- | Create instances of 'SDecide' for each type in the list.+-- | Create instances of 'SDecide', 'TestEquality', and 'TestCoercion' for each+-- type in the list. singDecideInstances :: DsMonad q => [Name] -> q [Dec] singDecideInstances = concatMapM singDecideInstance --- | Create instance of 'SDecide' for the given type.+-- | Create instance of 'SDecide', 'TestEquality', and 'TestCoercion' for the+-- given type. singDecideInstance :: DsMonad q => Name -> q [Dec] singDecideInstance name = singEqualityInstance sDecideClassDesc name @@ -146,9 +150,14 @@   dcons <- concatMapM (dsCon dtvbs data_ty) cons   let tyvars = map (DVarT . extractTvbName) dtvbs       kind = foldType (DConT name) tyvars-  (scons, _) <- singM [] $ mapM singCtor dcons+  (scons, _) <- singM [] $ mapM (singCtor name) dcons   eqInstance <- mkEqualityInstance Nothing kind dcons scons desc-  return $ decToTH eqInstance+  testInstances <-+    if className == sDecideClassName+       then traverse (mkTestInstance Nothing kind name dcons)+                     [TestEquality, TestCoercion]+       else pure []+  return $ decsToTH (eqInstance:testInstances)  -- | Create instances of 'SOrd' for the given types singOrdInstances :: DsMonad q => [Name] -> q [Dec]@@ -178,7 +187,7 @@ -- -- (Not to be confused with 'showShowInstance'.) singShowInstance :: DsMonad q => Name -> q [Dec]-singShowInstance = singInstance mkShowInstance "Show"+singShowInstance = singInstance (mkShowInstance ForPromotion) "Show"  -- | Create instances of 'SShow' for the given types --@@ -198,9 +207,10 @@   let tyvars    = map (DVarT . extractTvbName) dtvbs       kind      = foldType (DConT name) tyvars       data_decl = DataDecl name dtvbs dcons-      deriv_show_decl = DerivedDecl { ded_mb_cxt = Nothing-                                    , ded_type   = kind-                                    , ded_decl   = data_decl }+      deriv_show_decl = DerivedDecl { ded_mb_cxt     = Nothing+                                    , ded_type       = kind+                                    , ded_type_tycon = name+                                    , ded_decl       = data_decl }   (show_insts, _) <- singM [] $ singDerivedShowDecs deriv_show_decl   pure $ decsToTH show_insts @@ -210,6 +220,55 @@ showSingInstances :: DsMonad q => [Name] -> q [Dec] showSingInstances = concatMapM showSingInstance +-- | Create an instance for @'SingI' TyCon{N}@, where @N@ is the positive+-- number provided as an argument.+--+-- Note that the generated code requires the use of the @QuantifiedConstraints@+-- language extension.+singITyConInstances :: DsMonad q => [Int] -> q [Dec]+singITyConInstances = concatMapM singITyConInstance++-- | Create an instance for @'SingI' TyCon{N}@, where @N@ is the positive+-- number provided as an argument.+--+-- Note that the generated code requires the use of the @QuantifiedConstraints@+-- language extension.+singITyConInstance :: DsMonad q => Int -> q [Dec]+singITyConInstance n+  | n <= 0+  = fail $ "Argument must be a positive number (given " ++ show n ++ ")"+  | otherwise+  = do as <- replicateM n (qNewName "a")+       ks <- replicateM n (qNewName "k")+       k_last <- qNewName "k_last"+       f      <- qNewName "f"+       x      <- qNewName "x"+       let k_penult = last ks+           k_fun = ravel (map DVarT ks) (DVarT k_last)+           f_ty  = DVarT f+           a_tys = map DVarT as+           mk_fun arrow t1 t2 = arrow `DAppT` t1 `DAppT` t2+           matchable_apply_fun   = mk_fun DArrowT                (DVarT k_penult) (DVarT k_last)+           unmatchable_apply_fun = mk_fun (DConT tyFunArrowName) (DVarT k_penult) (DVarT k_last)+           ctxt = [ DForallT (map DPlainTV as)+                             (map (DAppT (DConT singIName)) a_tys)+                             (DConT singIName `DAppT` foldType f_ty a_tys)+                  , DConT equalityName+                      `DAppT` (DConT applyTyConName `DSigT`+                                mk_fun DArrowT matchable_apply_fun unmatchable_apply_fun)+                      `DAppT` DConT applyTyConAux1Name+                  ]+       pure $ decToTH+            $ DInstanceD+                Nothing Nothing ctxt+                (DConT singIName `DAppT` (DConT (mkTyConName n) `DAppT` (f_ty `DSigT` k_fun)))+                [DLetDec $ DFunD singMethName+                           [DClause [] $+                            wrapSingFun 1 DWildCardT $+                            DLamE [x] $+                            DVarE withSingIName `DAppE` DVarE x+                                                `DAppE` DVarE singMethName]]+ singInstance :: DsMonad q => DerivDesc q -> String -> Name -> q [Dec] singInstance mk_inst inst_name name = do   (tvbs, cons) <- getDataD ("I cannot make an instance of " ++ inst_name@@ -220,7 +279,7 @@   let data_decl = DataDecl name dtvbs dcons   raw_inst <- mk_inst Nothing data_ty data_decl   (a_inst, decs) <- promoteM [] $-                    promoteInstanceDec Map.empty raw_inst+                    promoteInstanceDec OMap.empty raw_inst   decs' <- singDecsM [] $ (:[]) <$> singInstD a_inst   return $ decsToTH (decs ++ decs') @@ -297,7 +356,7 @@ -- see comment at top of file buildMethLets :: UClassDecl -> [(Name, DExp)] buildMethLets (ClassDecl { cd_lde = LetDecEnv { lde_types = meth_sigs } }) =-  map mk_bind (Map.toList meth_sigs)+  map mk_bind (OMap.assocs meth_sigs)   where     mk_bind (meth_name, meth_ty) =       ( meth_name@@ -314,7 +373,7 @@                                             , lde_infix     = fixities                                             , lde_proms     = promoted_defaults                                             , lde_bound_kvs = meth_bound_kvs } }) =-  bindContext [foldPredTvbs (DConPr cls_name) cls_tvbs] $ do+  bindContext [foldTypeTvbs (DConT cls_name) cls_tvbs] $ do     (sing_sigs, _, tyvar_names, cxts, res_kis, singIDefunss)       <- unzip6 <$> zipWithM (singTySig no_meth_defns meth_sigs meth_bound_kvs)                              meth_names (map promoteValRhs meth_names)@@ -326,8 +385,8 @@     sing_meths <- mapM (uncurry (singLetDecRHS (Map.fromList tyvar_names)                                                (Map.fromList cxts)                                                res_ki_map))-                       (Map.toList default_defns)-    fixities' <- traverse (uncurry singInfixDecl) $ Map.toList fixities+                       (OMap.assocs default_defns)+    fixities' <- traverse (uncurry singInfixDecl) $ OMap.assocs fixities     cls_cxt' <- mapM singPred cls_cxt     return $ DClassD cls_cxt'                      (singClassName cls_name)@@ -337,15 +396,15 @@   where     no_meth_defns = error "Internal error: can't find declared method type"     always_sig    = error "Internal error: no signature for default method"-    meth_names    = Map.keys meth_sigs+    meth_names    = map fst $ OMap.assocs meth_sigs      mk_default_sig meth_name (DSigD s_name sty) bound_kvs (Just res_ki) =       DDefaultSigD s_name <$> add_constraints meth_name sty bound_kvs res_ki     mk_default_sig _ _ _ _ = error "Internal error: a singled signature isn't a signature."      add_constraints meth_name sty (_, bound_kvs) res_ki = do  -- Maybe monad-      prom_dflt <- Map.lookup meth_name promoted_defaults-      let default_pred = foldPred (DConPr equalityName)+      prom_dflt <- OMap.lookup meth_name promoted_defaults+      let default_pred = foldType (DConT equalityName)                                 -- NB: Need the res_ki here to prevent ambiguous                                 -- kinds in result-inferred default methods.                                 -- See #175@@ -382,6 +441,7 @@     inst_kis <- mapM promoteType inst_tys     meths <- concatMapM (uncurry sing_meth) ann_meths     return (DInstanceD Nothing+                       Nothing                        cxt'                        (foldl DAppT (DConT s_inst_name) inst_kis)                        meths)@@ -406,7 +466,7 @@               -- less confusing.               vis_cls_tvbs = drop (length cls_tvbs - length inst_kis) cls_tvbs -          sing_meth_ty :: Set Name -> DType+          sing_meth_ty :: OSet Name -> DType                        -> SgM (DType, [Name], DCxt, DKind)           sing_meth_ty bound_kvs inner_ty = do             -- Make sure to expand through type synonyms here! Not doing so@@ -416,11 +476,11 @@               <- singType bound_kvs (promoteValRhs name) raw_ty             pure (s_ty, tyvar_names, ctxt, res_ki) -      (s_ty, tyvar_names, ctxt, m_res_ki) <- case Map.lookup name inst_sigs of+      (s_ty, tyvar_names, ctxt, m_res_ki) <- case OMap.lookup name inst_sigs of         Just inst_sig -> do           -- We have an InstanceSig, so just single that type. Take care to           -- avoid binding the variables bound by the instance head as well.-          let inst_bound = foldMap (fvDType . predToType) cxt <> foldMap fvDType inst_kis+          let inst_bound = foldMap fvDType (cxt ++ inst_kis)           (s_ty, tyvar_names, ctxt, res_ki) <- sing_meth_ty inst_bound inst_sig           pure (s_ty, tyvar_names, ctxt, Just res_ki)         Nothing -> case mb_s_info of@@ -435,7 +495,7 @@              pure ( substType subst s_ty                  , map extractTvbName sing_tvbs-                 , map (substPred subst) ctxt+                 , map (substType subst) ctxt                  , m_res_ki )           _ -> do             mb_info <- dsReify name@@ -443,8 +503,8 @@               Just (DVarI _ (DForallT cls_tvbs _cls_pred inner_ty) _) -> do                 let subst = mk_subst cls_tvbs                     cls_kvb_names = foldMap (foldMap fvDType . extractTvbKind) cls_tvbs-                    cls_tvb_names = Set.fromList $ map extractTvbName cls_tvbs-                    cls_bound     = cls_kvb_names `Set.union` cls_tvb_names+                    cls_tvb_names = OSet.fromList $ map extractTvbName cls_tvbs+                    cls_bound     = cls_kvb_names `OSet.union` cls_tvb_names                 (s_ty, tyvar_names, ctxt, res_ki) <- sing_meth_ty cls_bound inner_ty                 pure ( substType subst s_ty                      , tyvar_names@@ -473,23 +533,23 @@                          , lde_proms     = proms                          , lde_bound_kvs = bound_kvs })               thing_inside = do-  let prom_list = Map.toList proms+  let prom_list = OMap.assocs proms   (typeSigs, letBinds, tyvarNames, cxts, res_kis, singIDefunss)     <- unzip6 <$> mapM (uncurry (singTySig defns types bound_kvs)) prom_list-  infix_decls' <- traverse (uncurry singInfixDecl) $ Map.toList infix_decls+  infix_decls' <- traverse (uncurry singInfixDecl) $ OMap.assocs infix_decls   let res_ki_map = Map.fromList [ (name, res_ki) | ((name, _), Just res_ki)                                                      <- zip prom_list res_kis ]   bindLets letBinds $ do     let_decs <- mapM (uncurry (singLetDecRHS (Map.fromList tyvarNames)                                              (Map.fromList cxts)                                              res_ki_map))-                     (Map.toList defns)+                     (OMap.assocs defns)     thing <- thing_inside     return (infix_decls' ++ typeSigs ++ let_decs, concat singIDefunss, thing) -singTySig :: Map Name ALetDecRHS  -- definitions-          -> Map Name DType       -- type signatures-          -> Map Name (Set Name)  -- bound kind variables+singTySig :: OMap Name ALetDecRHS  -- definitions+          -> OMap Name DType       -- type signatures+          -> OMap Name (OSet Name) -- bound kind variables           -> Name -> DType   -- the type is the promoted type, not the type sig!           -> SgM ( DLetDec               -- the new type signature                  , (Name, DExp)          -- the let-bind entry@@ -500,7 +560,7 @@                  ) singTySig defns types bound_kvs name prom_ty =   let sName = singValName name in-  case Map.lookup name types of+  case OMap.lookup name types of     Nothing -> do       num_args <- guess_num_args       (sty, tyvar_names) <- mk_sing_ty num_args@@ -528,14 +588,14 @@   where     guess_num_args :: SgM Int     guess_num_args =-      case Map.lookup name defns of+      case OMap.lookup name defns of         Nothing -> fail "Internal error: promotion known for something not let-bound."         Just (AValue _ n _) -> return n         Just (AFunction _ n _) -> return n -    lookup_bound_kvs :: SgM (Set Name)+    lookup_bound_kvs :: SgM (OSet Name)     lookup_bound_kvs =-      case Map.lookup name bound_kvs of+      case OMap.lookup name bound_kvs of         Nothing -> fail $ "Internal error: " ++ nameBase name ++ " has no type variable "                           ++ "bindings, despite having a type signature"         Just kvs -> pure kvs@@ -559,7 +619,7 @@   bindContext (Map.findWithDefault [] name cxts) $     case ld_rhs of       AValue prom num_arrows exp ->-        DValD (DVarPa (singValName name)) <$>+        DValD (DVarP (singValName name)) <$>         (wrapUnSingFun num_arrows prom <$> singExp exp (Map.lookup name res_kis))       AFunction prom_fun num_arrows clauses ->         let tyvar_names = case Map.lookup name bound_names of@@ -603,21 +663,21 @@ singPat var_proms = go   where     go :: ADPat -> QWithAux SingDSigPaInfos SgM DPat-    go (ADLitPa _lit) =+    go (ADLitP _lit) =       fail "Singling of literal patterns not yet supported"-    go (ADVarPa name) = do+    go (ADVarP name) = do       tyname <- case Map.lookup name var_proms of                   Nothing     ->                     fail "Internal error: unknown variable when singling pattern"                   Just tyname -> return tyname-      pure $ DVarPa (singValName name) `DSigPa` (singFamily `DAppT` DVarT tyname)-    go (ADConPa name pats) = DConPa (singDataConName name) <$> mapM go pats-    go (ADTildePa pat) = do+      pure $ DVarP (singValName name) `DSigP` (singFamily `DAppT` DVarT tyname)+    go (ADConP name pats) = DConP (singDataConName name) <$> mapM go pats+    go (ADTildeP pat) = do       qReportWarning         "Lazy pattern converted into regular pattern during singleton generation."       go pat-    go (ADBangPa pat) = DBangPa <$> go pat-    go (ADSigPa prom_pat pat ty) = do+    go (ADBangP pat) = DBangP <$> go pat+    go (ADSigP prom_pat pat ty) = do       pat' <- go pat       -- Normally, calling dPatToDExp would be dangerous, since it fails if the       -- supplied pattern contains any wildcard patterns. However, promotePat@@ -627,7 +687,7 @@       -- See Note [Singling pattern signatures].       addElement (dPatToDExp pat', DSigT prom_pat ty)       pure pat'-    go ADWildPa = pure DWildPa+    go ADWildP = pure DWildP  -- | If given a non-empty list of 'SingDSigPaInfos', construct a case expression -- that brings singleton equality constraints into scope via pattern-matching.@@ -638,7 +698,7 @@   | otherwise =       let (exps, sigs) = unzip exps_with_sigs           scrutinee = mkTupleDExp exps-          pats = map (DSigPa DWildPa . DAppT (DConT singFamilyName)) sigs+          pats = map (DSigP DWildP . DAppT (DConT singFamilyName)) sigs       in DCaseE scrutinee [DMatch (mkTupleDPat pats) exp]  -- Note [Annotate case return type]@@ -650,6 +710,11 @@ -- becomes "untouchable" in the case matches. See the OutsideIn paper. But, -- during singletonization, we *know* the return type. So, just add a type -- annotation. See #54.+--+-- In particular, we add a type annotation in a somewhat unorthodox fashion.+-- Instead of the usual `(x :: t)`, we use `id @t x`. See+-- Note [The id hack; or, how singletons learned to stop worrying and avoid+-- kind generalization] for an explanation of why we do this.  -- Note [Why error is so special] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -765,14 +830,17 @@   -- So: build a case   let caseExp = DCaseE (mkTupleDExp (map DVarE sNames))                        [DMatch (mkTupleDPat-                                (map ((DWildPa `DSigPa`) .+                                (map ((DWildP `DSigP`) .                                       (singFamily `DAppT`) .                                       DVarT) ty_names)) exp']   return $ wrapSingFun (length names) prom_lam $ DLamE sNames caseExp singExp (ADCaseE exp matches ret_ty) res_ki =-    -- See Note [Annotate case return type]-  DSigE <$> (DCaseE <$> singExp exp Nothing <*> mapM (singMatch res_ki) matches)-        <*> pure (singFamily `DAppT` (ret_ty `maybeSigT` res_ki))+    -- See Note [Annotate case return type] and+    --     Note [The id hack; or, how singletons learned to stop worrying and+    --           avoid kind generalization]+  DAppE (DAppTypeE (DVarE 'id)+                   (singFamily `DAppT` (ret_ty `maybeSigT` res_ki)))+    <$> (DCaseE <$> singExp exp Nothing <*> mapM (singMatch res_ki) matches) singExp (ADLetE env exp) res_ki = do   -- We intentionally discard the SingI instances for exp's defunctionalization   -- symbols, as we also do not generate the declarations for the@@ -783,12 +851,13 @@   exp' <- singExp exp (Just ty)   pure $ DSigE exp' $ DConT singFamilyName `DAppT` DSigT prom_exp ty --- See Note [DerivedDecl]+-- See Note [DerivedDecl] in Data.Singletons.Syntax singDerivedEqDecs :: DerivedEqDecl -> SgM [DDec]-singDerivedEqDecs (DerivedDecl { ded_mb_cxt = mb_ctxt-                               , ded_type   = ty-                               , ded_decl   = DataDecl _ _ cons }) = do-  (scons, _) <- singM [] $ mapM singCtor cons+singDerivedEqDecs (DerivedDecl { ded_mb_cxt     = mb_ctxt+                               , ded_type       = ty+                               , ded_type_tycon = ty_tycon+                               , ded_decl       = DataDecl _ _ cons }) = do+  (scons, _) <- singM [] $ mapM (singCtor ty_tycon) cons   mb_sctxt <- mapM (mapM singPred) mb_ctxt   kind <- promoteType ty   sEqInst <- mkEqualityInstance mb_sctxt kind cons scons sEqClassDesc@@ -801,36 +870,50 @@   -- all occurrences of SEq with SDecide in the context.   let mb_sctxtDecide = fmap (map sEqToSDecide) mb_sctxt   sDecideInst <- mkEqualityInstance mb_sctxtDecide kind cons scons sDecideClassDesc-  return [sEqInst, sDecideInst]+  testInsts <- traverse (mkTestInstance mb_sctxtDecide kind ty_tycon cons)+                        [TestEquality, TestCoercion]+  return (sEqInst:sDecideInst:testInsts)  -- Walk a DPred, replacing all occurrences of SEq with SDecide. sEqToSDecide :: DPred -> DPred-sEqToSDecide = modifyConNameDPred $ \n ->+sEqToSDecide = modifyConNameDType $ \n ->   -- Why don't we directly compare n to sEqClassName? Because n is almost certainly   -- produced from a call to singClassName, which uses unqualified Names. Ugh.   if nameBase n == nameBase sEqClassName      then sDecideClassName      else n --- See Note [DerivedDecl]+-- See Note [DerivedDecl] in Data.Singletons.Syntax singDerivedShowDecs :: DerivedShowDecl -> SgM [DDec]-singDerivedShowDecs (DerivedDecl { ded_mb_cxt = mb_cxt-                                 , ded_type   = ty-                                 , ded_decl   = DataDecl _ _ cons }) = do-    z <- qNewName "z"-    -- Derive the Show instance for the singleton type, like this:+singDerivedShowDecs (DerivedDecl { ded_mb_cxt     = mb_cxt+                                 , ded_type       = ty+                                 , ded_type_tycon = ty_tycon+                                 , ded_decl       = data_decl }) = do+    -- Generate a Show instance for a singleton type, like this:     ---    --   deriving instance (ShowSing a, ShowSing b) => Sing (Sing (z :: Either a b))+    --   instance (ShowSing a, ShowSing b) => Show (SEither (z :: Either a b)) where+    --     showsPrec p (SLeft (sl :: Sing l)) =+    --       showParen (p > 10) $ showString "SLeft " . showsPrec 11 sl+    --         :: ShowSing' l => ShowS+    --     showsPrec p (SRight (sr :: Sing r)) =+    --       showParen (p > 10) $ showString "SRight " . showsPrec 11 sr+    --         :: ShowSing' r => ShowS     --     -- Be careful: we want to generate an instance context that uses ShowSing,     -- not SShow.-    show_cxt <- inferConstraintsDef (fmap mkShowSingContext mb_cxt)-                                    (DConPr showSingName)-                                    ty cons-    let show_inst = DStandaloneDerivD Nothing show_cxt-                      (DConT showName `DAppT` (singFamily `DAppT` DSigT (DVarT z) ty))-    pure [show_inst]+    show_sing_inst <- mkShowInstance (ForShowSing ty_tycon) mb_cxt ty data_decl+    pure [toInstanceD show_sing_inst]+  where+    toInstanceD :: UInstDecl -> DDec+    toInstanceD (InstDecl { id_cxt = cxt, id_name = inst_name+                          , id_arg_tys = inst_tys, id_meths = ann_meths }) =+      DInstanceD Nothing Nothing cxt (foldType (DConT inst_name) inst_tys)+                 (map (DLetDec . toFunD) ann_meths) +    toFunD :: (Name, ULetDecRHS) -> DLetDec+    toFunD (fun_name, UFunction clauses) = DFunD fun_name clauses+    toFunD (val_name, UValue rhs)        = DValD (DVarP val_name) rhs+ isException :: DExp -> Bool isException (DVarE n)             = nameBase n == "sUndefined" isException (DConE {})            = False@@ -872,3 +955,85 @@ maybeSigT :: DType -> Maybe DKind -> DType maybeSigT ty Nothing   = ty maybeSigT ty (Just ki) = ty `DSigT` ki++{-+Note [The id hack; or, how singletons learned to stop worrying and avoid kind generalization]+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~+GHC 8.8 was a time of great change. In particular, 8.8 debuted a fix for+Trac #15141 (decideKindGeneralisationPlan is too complicated). To fix this, a+wily GHC developer—who shall remain unnamed, but whose username rhymes with+schmoldfire—decided to make decideKindGeneralisationPlan less complicated by,+well, removing the whole thing. One consequence of this is that local+definitions are now kind-generalized (whereas they would not have been+previously).++While schmoldfire had the noblest of intentions when authoring his fix, he+unintentionally made life much harder for singletons. Why? Consider the+following program:++  class Foo a where+    bar :: a -> (a -> b) -> b+    baz :: a++  quux :: Foo a => a -> a+  quux x = x `bar` \_ -> baz++When singled, this program will turn into something like this:++  type family Quux (x :: a) :: a where+    Quux x = Bar x (LambdaSym1 x)++  sQuux :: forall a (x :: a). SFoo a => Sing x -> Sing (Quux x :: a)+  sQuux (sX :: Sing x)+    = sBar sX+        ((singFun1 @(LambdaSym1 x))+           (\ sArg+              -> case sArg of {+                   (_ :: Sing arg)+                     -> (case sArg of { _ -> sBaz }) ::+                          Sing (Case x arg arg) }))++  type family Case x arg t where+    Case x arg _ = Baz+  type family Lambda x t where+    Lambda x arg = Case x arg arg+  data LambdaSym1 x t+  type instance Apply (LambdaSym1 x) t = Lambda x t++The high-level bit is the explicit `Sing (Case x arg arg)` signature. Question:+what is the kind of `Case x arg arg`? The answer depends on whether local+definitions are kind-generalized or not!++1. If local definitions are *not* kind-generalized (i.e., the status quo before+   GHC 8.8), then `Case x arg arg :: a`.+2. If local definitions *are* kind-generalized (i.e., the status quo in GHC 8.8+   and later), then `Case x arg arg :: k` for some fresh kind variable `k`.++Unfortunately, the kind of `Case x arg arg` *must* be `a` in order for `sQuux`+to type-check. This means that the code above suddenly stopped working in GHC+8.8. What's more, we can't just remove these explicit signatures, as there is+code elsewhere in `singletons` that crucially relies on them to guide type+inference along (e.g., `sShowParen` in `Data.Singletons.Prelude.Show`).++Luckily, there is an ingenious hack that lets us the benefits of explicit+signatures without the pain of kind generalization: our old friend, the `id`+function. The plan is as follows: instead of generating this code:++  (case sArg of ...) :: Sing (Case x arg arg)++We instead generate this code:++  id @(Sing (Case x arg arg)) (case sArg of ...)++That's it! This works because visible type arguments in terms do not get kind-+generalized, unlike top-level or local signatures. Now `Case x arg arg`'s kind+is not generalized, and all is well. We dub this: the `id` hack.++One might wonder: will we need the `id` hack around forever? Perhaps not. While+GHC 8.8 removed the decideKindGeneralisationPlan function, there have been+rumblings that a future version of GHC may bring it back (in a limited form).+If this happens, it is possibly that GHC's attitude towards kind-generalizing+local definitons may change *again*, which could conceivably render the `id`+hack unnecessary. This is all speculation, of course, so all we can do now is+wait and revisit this design at a later date.+-}
src/Data/Singletons/Single/Data.hs view
@@ -11,6 +11,7 @@ module Data.Singletons.Single.Data where  import Language.Haskell.TH.Desugar+import Language.Haskell.TH.Desugar.OSet (OSet) import Language.Haskell.TH.Syntax import Data.Singletons.Single.Defun import Data.Singletons.Single.Monad@@ -21,8 +22,7 @@ import Data.Singletons.Names import Data.Singletons.Syntax import Control.Monad-import qualified Data.Set as Set-import Data.Set (Set)+import Data.Foldable  -- We wish to consider the promotion of "Rep" to be * -- not a promoted data constructor.@@ -30,7 +30,7 @@ singDataD (DataDecl name tvbs ctors) = do   let tvbNames = map extractTvbName tvbs   k <- promoteType (foldType (DConT name) (map DVarT tvbNames))-  ctors' <- mapM singCtor ctors+  ctors' <- mapM (singCtor name) ctors   ctorFixities <-     -- try to reify the fixity declarations for the constructors and then     -- singletonize them. In case the reification fails, we default to an@@ -48,11 +48,11 @@   toSingClauses       <- mapM mkToSingClause ctors   emptyToSingClause   <- mkEmptyToSingClause   let singKindInst =-        DInstanceD Nothing+        DInstanceD Nothing Nothing                    (map (singKindConstraint . DVarT) tvbNames)                    (DAppT (DConT singKindClassName) k)-                   [ DTySynInstD demoteName $ DTySynEqn-                      [k]+                   [ DTySynInstD $ DTySynEqn Nothing+                      (DConT demoteName `DAppT` k)                       (foldType (DConT name)                         (map (DAppT demote . DVarT) tvbNames))                    , DLetDec $ DFunD fromSingName@@ -60,15 +60,17 @@                    , DLetDec $ DFunD toSingName                                (toSingClauses   `orIfEmpty` [emptyToSingClause]) ] -  -- e.g. type SNat = (Sing :: Nat -> Type)-  let kindedSingTy = DArrowT `DAppT` k `DAppT` DConT typeKindName-      kindedSynInst =-        DTySynD (singTyConName name)-                []-                (singFamily `DSigT` kindedSingTy)+  let singDataName = singTyConName name+      -- e.g. type instance Sing @Nat = SNat+      singSynInst =+        DTySynInstD $ DTySynEqn Nothing+                                (DConT singFamilyName `DAppKindT` k)+                                (DConT singDataName)+      kindedSingTy = DForallT (map DPlainTV tvbNames) [] $+                     DArrowT `DAppT` k `DAppT` DConT typeKindName -  return $ (DDataInstD Data [] singFamilyName [] (Just kindedSingTy) ctors' []) :-           kindedSynInst :+  return $ (DDataD Data [] singDataName [] (Just kindedSingTy) ctors' []) :+           singSynInst :            singKindInst :            ctorFixities   where -- in the Rep case, the names of the constructors are in the wrong scope@@ -83,7 +85,7 @@           let (cname, numArgs) = extractNameArgs c           cname' <- mkConName cname           varNames <- replicateM numArgs (qNewName "b")-          return $ DClause [DConPa (singDataConName cname) (map DVarPa varNames)]+          return $ DClause [DConP (singDataConName cname) (map DVarP varNames)]                            (foldExp                               (DConE cname')                               (map (DAppE (DVarE fromSingName) . DVarE) varNames))@@ -98,9 +100,9 @@           let varPats        = zipWith mkToSingVarPat varNames promoted               recursiveCalls = zipWith mkRecursiveCall varNames promoted           return $-            DClause [DConPa cname' varPats]+            DClause [DConP cname' varPats]                     (multiCase recursiveCalls-                               (map (DConPa someSingDataName . listify . DVarPa)+                               (map (DConP someSingDataName . listify . DVarP)                                     svarNames)                                (DAppE (DConE someSingDataName)                                          (foldExp (DConE (singDataConName cname))@@ -108,7 +110,7 @@          mkToSingVarPat :: Name -> DKind -> DPat         mkToSingVarPat varName ki =-          DSigPa (DVarPa varName) (DAppT (DConT demoteName) ki)+          DSigP (DVarP varName) (DAppT (DConT demoteName) ki)          mkRecursiveCall :: Name -> DKind -> DExp         mkRecursiveCall var_name ki =@@ -118,21 +120,21 @@         mkEmptyFromSingClause :: SgM DClause         mkEmptyFromSingClause = do           x <- qNewName "x"-          pure $ DClause [DVarPa x]+          pure $ DClause [DVarP x]                $ DCaseE (DVarE x) []          mkEmptyToSingClause :: SgM DClause         mkEmptyToSingClause = do           x <- qNewName "x"-          pure $ DClause [DVarPa x]+          pure $ DClause [DVarP x]                $ DConE someSingDataName `DAppE` DCaseE (DVarE x) []  -- refine a constructor.-singCtor :: DCon -> SgM DCon+singCtor :: Name -> DCon -> SgM DCon  -- polymorphic constructors are handled just  -- like monomorphic ones -- the polymorphism in  -- the kind is automatic-singCtor (DCon _tvbs cxt name fields rty)+singCtor dataName (DCon _tvbs cxt name fields rty)   | not (null cxt)   = fail "Singling of constrained constructors not yet supported"   | otherwise@@ -147,16 +149,16 @@   let bound_kvs = foldMap fvDType kinds   args <- zipWithM (buildArgType bound_kvs) types indices   rty' <- promoteType rty-  let tvbs = map DPlainTV (Set.toList bound_kvs) ++ zipWith DKindedTV indexNames kinds+  let tvbs = map DPlainTV (toList bound_kvs) ++ zipWith DKindedTV indexNames kinds       kindedIndices = zipWith DSigT indices kinds    -- SingI instance for data constructor   emitDecs-    [DInstanceD Nothing-                (map (DAppPr (DConPr singIName)) indices)+    [DInstanceD Nothing Nothing+                (map (DAppT (DConT singIName)) indices)                 (DAppT (DConT singIName)                        (foldType pCon kindedIndices))-                [DLetDec $ DValD (DVarPa singMethName)+                [DLetDec $ DValD (DVarP singMethName)                        (foldExp sCon (map (const $ DVarE singMethName) types))]]   -- SingI instances for defunctionalization symbols. Note that we don't   -- support contexts in constructors at the moment, so it's fine for now to@@ -174,8 +176,8 @@                 []                 sName                 conFields-                (DConT singFamilyName `DAppT` foldType pCon indices)-  where buildArgType :: Set Name -> DType -> DType -> SgM DType+                (DConT (singTyConName dataName) `DAppT` foldType pCon indices)+  where buildArgType :: OSet Name -> DType -> DType -> SgM DType         buildArgType bound_kvs ty index = do           (ty', _, _, _, _, _) <- singType bound_kvs index ty           return ty'
src/Data/Singletons/Single/Defun.hs view
@@ -45,15 +45,9 @@ -- Note that singDefuns takes Maybe DKinds for the promoted argument and result -- types, in case we have an entity whose type needs to be inferred. -- See Note [singDefuns and type inference].------ Note that in the particular case of a data constructor, we actually generate--- /two/ SingI instances partial application—one for the defunctionalization--- symbol, and one for the data constructor placed inside TyCon{N}.--- See Note [SingI instances for partially applied constructors]. singDefuns :: Name      -- The Name of the thing to promote.            -> NameSpace -- Whether the above Name is a value, data constructor,                         -- or a type constructor.-                        -- See Note [SingI instances for partially applied constructors]            -> DCxt      -- The type's context.            -> [Maybe DKind] -- The promoted argument types (if known).            -> Maybe DKind   -- The promoted result type (if known).@@ -98,7 +92,7 @@                  (map extractTvbName tvbs)          singI_ctxt :: DCxt-        singI_ctxt = map (DAppPr (DConPr singIName) . tvbToType) tvbs+        singI_ctxt = map (DAppT (DConT singIName) . tvbToType) tvbs          mk_inst_ty :: DType -> DType         mk_inst_ty inst_head@@ -119,29 +113,21 @@         mb_inst_kind = foldr buildTyFunArrow_maybe mb_ty_res mb_tyss          new_insts :: [DDec]-        new_insts-          | DataName <- ns-          = -- See Note [SingI instances for partially applied constructors]-            let s_data_con = DConE $ singDataConName n in-            [ mk_inst defun_inst_ty s_data_con-            , mk_inst tycon_inst_ty s_data_con ]-          | otherwise-          = [mk_inst defun_inst_ty $ DVarE $ singValName n]+        new_insts = [DInstanceD Nothing Nothing+                                (sty_ctxt ++ singI_ctxt)+                                (DConT singIName `DAppT` mk_inst_ty defun_inst_ty)+                                [DLetDec $ DValD (DVarP singMethName)+                                         $ wrapSingFun sing_fun_num defun_inst_ty+                                         $ mk_sing_fun_expr sing_exp ]]           where-            mk_inst :: DType -> DExp -> DDec-            mk_inst inst_head sing_exp-              = DInstanceD Nothing-                           (sty_ctxt ++ singI_ctxt)-                           (DConT singIName `DAppT` mk_inst_ty inst_head)-                           [DLetDec $ DValD (DVarPa singMethName)-                                    $ wrapSingFun sing_fun_num inst_head-                                    $ mk_sing_fun_expr sing_exp ]--            defun_inst_ty, tycon_inst_ty :: DType+            defun_inst_ty :: DType             defun_inst_ty = foldType (DConT (promoteTySym n sym_num)) tvb_tys-            tycon_inst_ty = DConT (mkTyConName sing_fun_num) `DAppT`-                            foldType (DConT n) tvb_tys +            sing_exp :: DExp+            sing_exp = case ns of+                         DataName -> DConE $ singDataConName n+                         _        -> DVarE $ singValName n+ {- Note [singDefuns and type inference] ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~@@ -176,38 +162,4 @@ will /also/ fail to typecheck due to a missing SEq constraint. Therefore, this design choice fits within the existing tradition of type inference in singletons.--Note [SingI instances for partially applied constructors]-~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~-Unlike normal functions, where we generate one SingI instance for each of its-partial applications (one per defunctionalization symbol), we generate *two*-SingI instances for each partial application of a data constructor. That is,-if we have:--  data D a where-    K :: a -> D a--K has an partial application, so we will generate the following two SingI-instances:--  instance SingI KSym0          where sing = singFun1 SK-  instance SingI (TyCon1 KSym0) where sing = singFun1 SK--The first instance is exactly the same as what we'd generate for a normal,-partially applied function's defun symbol. The second one, while functionally-equivalent, is a bit dissatisfying: in general, adopting this approach means-that we end up generating many instances of the form:--  instance SingI (TyCon1 S1)-  instance SingI (TyCon1 S2)-  ...--Ideally, we'd have a single instance SingI (TyCon1 s) to rule them all. But-doing so would require writing something akin to:--  instance (forall a. SingI a => SingI (f a)) => SingI (TyCon1 f) where-    sing = SLambda $ \(x :: Sing a) -> withSingI x $ sing @_ @(f a)--But this would require quantified constraints. Until GHC gains these, we-compensate by generating out several SingI (TyCon1 s) instances. -}
src/Data/Singletons/Single/Eq.hs view
@@ -31,29 +31,52 @@   methClauses <- if null sctors                  then (:[]) <$> mkEmpty                  else mapM mkMeth sctorPairs-  constraints <- inferConstraintsDef mb_ctxt (DConPr className) k ctors-  return $ DInstanceD Nothing+  constraints <- inferConstraintsDef mb_ctxt (DConT className) k ctors+  return $ DInstanceD Nothing Nothing                      constraints                      (DAppT (DConT className) k)                      [DLetDec $ DFunD methName methClauses] +data TestInstance = TestEquality+                  | TestCoercion++-- Make an instance of TestEquality or TestCoercion by leveraging SDecide.+mkTestInstance :: DsMonad q => Maybe DCxt -> DKind+               -> Name   -- ^ The name of the data type+               -> [DCon] -- ^ The /original/ constructors (for inferring the instance context)+               -> TestInstance -> q DDec+mkTestInstance mb_ctxt k data_name ctors ti = do+  constraints <- inferConstraintsDef mb_ctxt (DConT sDecideClassName) k ctors+  pure $ DInstanceD Nothing Nothing+                    constraints+                    (DAppT (DConT tiClassName)+                           (DConT (singTyConName data_name)+                             `DSigT` (DArrowT `DAppT` k `DAppT` DConT typeKindName)))+                    [DLetDec $ DFunD tiMethName+                                     [DClause [] (DVarE tiDefaultName)]]+  where+    (tiClassName, tiMethName, tiDefaultName) =+      case ti of+        TestEquality -> (testEqualityClassName, testEqualityMethName, decideEqualityName)+        TestCoercion -> (testCoercionClassName, testCoercionMethName, decideCoercionName)+ mkEqMethClause :: Quasi q => (DCon, DCon) -> q DClause mkEqMethClause (c1, c2)   | lname == rname = do     lnames <- replicateM lNumArgs (qNewName "a")     rnames <- replicateM lNumArgs (qNewName "b")-    let lpats = map DVarPa lnames-        rpats = map DVarPa rnames+    let lpats = map DVarP lnames+        rpats = map DVarP rnames         lvars = map DVarE lnames         rvars = map DVarE rnames     return $ DClause-      [DConPa lname lpats, DConPa rname rpats]+      [DConP lname lpats, DConP rname rpats]       (allExp (zipWith (\l r -> foldExp (DVarE sEqMethName) [l, r])                         lvars rvars))   | otherwise =     return $ DClause-      [DConPa lname (replicate lNumArgs DWildPa),-       DConPa rname (replicate rNumArgs DWildPa)]+      [DConP lname (replicate lNumArgs DWildP),+       DConP rname (replicate rNumArgs DWildP)]       (DConE $ singDataConName falseName)   where allExp :: [DExp] -> DExp         allExp [] = DConE $ singDataConName trueName@@ -65,39 +88,39 @@  mkEmptyEqMethClause :: Applicative q => q DClause mkEmptyEqMethClause =-  pure $ DClause [DWildPa, DWildPa]+  pure $ DClause [DWildP, DWildP]        $ DConE strueName  mkDecideMethClause :: Quasi q => (DCon, DCon) -> q DClause mkDecideMethClause (c1, c2)   | lname == rname =     if lNumArgs == 0-    then return $ DClause [DConPa lname [], DConPa rname []]+    then return $ DClause [DConP lname [], DConP rname []]                           (DAppE (DConE provedName) (DConE reflName))     else do       lnames <- replicateM lNumArgs (qNewName "a")       rnames <- replicateM lNumArgs (qNewName "b")       contra <- qNewName "contra"-      let lpats = map DVarPa lnames-          rpats = map DVarPa rnames+      let lpats = map DVarP lnames+          rpats = map DVarP rnames           lvars = map DVarE lnames           rvars = map DVarE rnames       refl <- qNewName "refl"       return $ DClause-        [DConPa lname lpats, DConPa rname rpats]+        [DConP lname lpats, DConP rname rpats]         (DCaseE (mkTupleDExp $                  zipWith (\l r -> foldExp (DVarE sDecideMethName) [l, r])                          lvars rvars)                 ((DMatch (mkTupleDPat (replicate lNumArgs-                                        (DConPa provedName [DConPa reflName []])))+                                        (DConP provedName [DConP reflName []])))                         (DAppE (DConE provedName) (DConE reflName))) :-                 [DMatch (mkTupleDPat (replicate i DWildPa ++-                                       DConPa disprovedName [DVarPa contra] :-                                       replicate (lNumArgs - i - 1) DWildPa))+                 [DMatch (mkTupleDPat (replicate i DWildP +++                                       DConP disprovedName [DVarP contra] :+                                       replicate (lNumArgs - i - 1) DWildP))                          (DAppE (DConE disprovedName)                                 (DLamE [refl] $                                  DCaseE (DVarE refl)-                                        [DMatch (DConPa reflName []) $+                                        [DMatch (DConP reflName []) $                                          (DAppE (DVarE contra)                                                 (DConE reflName))]))                  | i <- [0..lNumArgs-1] ]))@@ -105,8 +128,8 @@   | otherwise = do     x <- qNewName "x"     return $ DClause-      [DConPa lname (replicate lNumArgs DWildPa),-       DConPa rname (replicate rNumArgs DWildPa)]+      [DConP lname (replicate lNumArgs DWildP),+       DConP rname (replicate rNumArgs DWildP)]       (DAppE (DConE disprovedName) (DLamE [x] (DCaseE (DVarE x) [])))    where@@ -116,5 +139,5 @@ mkEmptyDecideMethClause :: Quasi q => q DClause mkEmptyDecideMethClause = do   x <- qNewName "x"-  pure $ DClause [DVarPa x, DWildPa]+  pure $ DClause [DVarP x, DWildP]        $ DConE provedName `DAppE` DCaseE (DVarE x) []
src/Data/Singletons/Single/Monad.hs view
@@ -29,7 +29,6 @@ import Control.Monad.Reader import Control.Monad.Writer import Control.Applicative-import Control.Monad.Fail  -- environment during singling data SgEnv =
src/Data/Singletons/Single/Type.hs view
@@ -9,16 +9,17 @@ module Data.Singletons.Single.Type where  import Language.Haskell.TH.Desugar+import qualified Language.Haskell.TH.Desugar.OSet as OSet+import Language.Haskell.TH.Desugar.OSet (OSet) import Language.Haskell.TH.Syntax import Data.Singletons.Names import Data.Singletons.Single.Monad import Data.Singletons.Promote.Type import Data.Singletons.Util import Control.Monad-import qualified Data.Set as Set-import Data.Set (Set)+import Data.Foldable -singType :: Set Name       -- the set of bound kind variables in this scope+singType :: OSet Name      -- the set of bound kind variables in this scope                            -- see Note [Explicitly binding kind variables]                            -- in Data.Singletons.Promote.Monad          -> DType          -- the promoted version of the thing classified by...@@ -41,9 +42,9 @@       tau   = ravel args' res'       -- Make sure to subtract out the bound variables currently in scope, lest we       -- accidentally shadow them in this type signature.-      kv_names_to_bind = foldMap fvDType (prom_args ++ map predToType cxt' ++ [prom_res])-                             Set.\\ bound_kvs-      kvs_to_bind      = Set.toList kv_names_to_bind+      kv_names_to_bind = foldMap fvDType (prom_args ++ cxt' ++ [prom_res])+                            OSet.\\ bound_kvs+      kvs_to_bind      = toList kv_names_to_bind   let ty' = DForallT (map DPlainTV kvs_to_bind ++ zipWith DKindedTV arg_names prom_args)                      cxt' tau   return (ty', num_args, arg_names, cxt, prom_args, prom_res)@@ -51,19 +52,24 @@ singPred :: DPred -> SgM DPred singPred = singPredRec [] -singPredRec :: [DType] -> DPred -> SgM DPred-singPredRec _cxt (DForallPr {}) =+singPredRec :: [DTypeArg] -> DPred -> SgM DPred+singPredRec _cxt (DForallT {}) =   fail "Singling of quantified constraints not yet supported"-singPredRec ctx (DAppPr pr ty) = singPredRec (ty : ctx) pr-singPredRec _ctx (DSigPr _pr _ki) =+singPredRec ctx (DAppT pr ty) = singPredRec (DTANormal ty : ctx) pr+singPredRec ctx (DAppKindT pr ki) = singPredRec (DTyArg ki : ctx) pr+singPredRec _ctx (DSigT _pr _ki) =   fail "Singling of constraints with explicit kinds not yet supported"-singPredRec _ctx (DVarPr _n) =+singPredRec _ctx (DVarT _n) =   fail "Singling of contraint variables not yet supported"-singPredRec ctx (DConPr n)+singPredRec ctx (DConT n)   | n == equalityName   = fail "Singling of type equality constraints not yet supported"   | otherwise = do-    kis <- mapM promoteType ctx+    kis <- mapM promoteTypeArg ctx     let sName = singClassName n-    return $ foldPred (DConPr sName) kis-singPredRec _ctx DWildCardPr = return DWildCardPr  -- it just might work+    return $ applyDType (DConT sName) kis+singPredRec _ctx DWildCardT = return DWildCardT  -- it just might work+singPredRec _ctx DArrowT =+  fail "(->) spotted at head of a constraint"+singPredRec _ctx (DLitT {}) =+  fail "Type-level literal spotted at head of a constraint"
src/Data/Singletons/Syntax.hs view
@@ -8,7 +8,7 @@ -}  {-# LANGUAGE DataKinds, TypeFamilies, PolyKinds, DeriveDataTypeable,-             StandaloneDeriving, FlexibleInstances, ConstraintKinds #-}+             FlexibleInstances, ConstraintKinds #-}  module Data.Singletons.Syntax where @@ -16,10 +16,9 @@ import Data.Kind (Constraint, Type) import Language.Haskell.TH.Syntax hiding (Type) import Language.Haskell.TH.Desugar-import Data.Map.Strict ( Map )-import qualified Data.Map.Strict as Map-import Data.Set ( Set )-import Data.Semigroup (Semigroup(..))+import qualified Language.Haskell.TH.Desugar.OMap.Strict as OMap+import Language.Haskell.TH.Desugar.OMap.Strict (OMap)+import Language.Haskell.TH.Desugar.OSet (OSet)  type VarPromotions = [(Name, Name)] -- from term-level name to type-level name @@ -27,7 +26,7 @@ data PromDPatInfos = PromDPatInfos   { prom_dpat_vars    :: VarPromotions       -- Maps term-level pattern variables to their promoted, type-level counterparts.-  , prom_dpat_sig_kvs :: Set Name+  , prom_dpat_sig_kvs :: OSet Name       -- Kind variables bound by DSigPas.       -- See Note [Explicitly binding kind variables] in Data.Singletons.Promote.Monad   }@@ -49,7 +48,7 @@ data DataDecl = DataDecl Name [DTyVarBndr] [DCon]  -- The parts of type synonyms that are relevant to singletons.-data TySynDecl = TySynDecl Name [DTyVarBndr]+data TySynDecl = TySynDecl Name [DTyVarBndr] DType  -- The parts of open type families that are relevant to singletons. type OpenTypeFamilyDecl = TypeFamilyDecl 'Open@@ -73,7 +72,7 @@ data InstDecl  ann = InstDecl { id_cxt     :: DCxt                               , id_name    :: Name                               , id_arg_tys :: [DType]-                              , id_sigs    :: Map Name DType+                              , id_sigs    :: OMap Name DType                               , id_meths   :: [(Name, LetDecRHS ann)] }  type UClassDecl = ClassDecl Unannotated@@ -106,15 +105,15 @@                     ADExp DType  -- A DPat with a pattern-signature node annotated with its type-level equivalent-data ADPat = ADLitPa Lit-           | ADVarPa Name-           | ADConPa Name [ADPat]-           | ADTildePa ADPat-           | ADBangPa ADPat-           | ADSigPa DType -- The promoted pattern. Will not contain any wildcards,-                           -- as per Note [Singling pattern signatures]-                     ADPat DType-           | ADWildPa+data ADPat = ADLitP Lit+           | ADVarP Name+           | ADConP Name [ADPat]+           | ADTildeP ADPat+           | ADBangP ADPat+           | ADSigP DType -- The promoted pattern. Will not contain any wildcards,+                          -- as per Note [Singling pattern signatures]+                    ADPat DType+           | ADWildP  data ADMatch = ADMatch VarPromotions ADPat ADExp data ADClause = ADClause VarPromotions@@ -145,11 +144,11 @@ type ULetDecRHS = LetDecRHS Unannotated  data LetDecEnv ann = LetDecEnv-                   { lde_defns :: Map Name (LetDecRHS ann)-                   , lde_types :: Map Name DType   -- type signatures-                   , lde_infix :: Map Name Fixity  -- infix declarations-                   , lde_proms :: IfAnn ann (Map Name DType) () -- possibly, promotions-                   , lde_bound_kvs :: IfAnn ann (Map Name (Set Name)) ()+                   { lde_defns :: OMap Name (LetDecRHS ann)+                   , lde_types :: OMap Name DType  -- type signatures+                   , lde_infix :: OMap Name Fixity -- infix declarations+                   , lde_proms :: IfAnn ann (OMap Name DType) () -- possibly, promotions+                   , lde_bound_kvs :: IfAnn ann (OMap Name (OSet Name)) ()                      -- The set of bound variables in scope.                      -- See Note [Explicitly binding kind variables]                      -- in Data.Singletons.Promote.Monad@@ -162,16 +161,16 @@     LetDecEnv (defns1 <> defns2) (types1 <> types2) (infx1 <> infx2) () ()  instance Monoid ULetDecEnv where-  mempty = LetDecEnv Map.empty Map.empty Map.empty () ()+  mempty = LetDecEnv OMap.empty OMap.empty OMap.empty () ()  valueBinding :: Name -> ULetDecRHS -> ULetDecEnv-valueBinding n v = emptyLetDecEnv { lde_defns = Map.singleton n v }+valueBinding n v = emptyLetDecEnv { lde_defns = OMap.singleton n v }  typeBinding :: Name -> DType -> ULetDecEnv-typeBinding n t = emptyLetDecEnv { lde_types = Map.singleton n t }+typeBinding n t = emptyLetDecEnv { lde_types = OMap.singleton n t }  infixDecl :: Fixity -> Name -> ULetDecEnv-infixDecl f n = emptyLetDecEnv { lde_infix = Map.singleton n f }+infixDecl f n = emptyLetDecEnv { lde_infix = OMap.singleton n f }  emptyLetDecEnv :: ULetDecEnv emptyLetDecEnv = mempty@@ -182,7 +181,7 @@     go acc [] = return acc     go acc (DFunD name clauses : rest) =       go (valueBinding name (UFunction clauses) <> acc) rest-    go acc (DValD (DVarPa name) exp : rest) =+    go acc (DValD (DVarP name) exp : rest) =       go (valueBinding name (UValue exp) <> acc) rest     go acc (dec@(DValD {}) : rest) = do       flattened <- flattenDValD dec@@ -195,9 +194,10 @@  -- See Note [DerivedDecl] data DerivedDecl (cls :: Type -> Constraint) = DerivedDecl-  { ded_mb_cxt :: Maybe DCxt-  , ded_type   :: DType-  , ded_decl   :: DataDecl+  { ded_mb_cxt     :: Maybe DCxt+  , ded_type       :: DType+  , ded_type_tycon :: Name+  , ded_decl       :: DataDecl   }  type DerivedEqDecl   = DerivedDecl Eq@@ -219,15 +219,16 @@    a deriving clause (ded_mb_cxt) 2. The datatype, applied to some number of type arguments, as in the    instance declaration (ded_type)-3. The datatype's original information, as provided through DataDecl (ded_decl)+3. The datatype name (ded_type_tycon), cached for convenience+4. The datatype's constructors (ded_cons)  Why are these instances handled outside of partitionDecs?  * Deriving Eq in singletons not only derives PEq/SEq instances, but it also-  derives SDecide instances. This additional complication makes Eq difficult-  to integrate with the other deriving machinery, so we handle it specially-  in Data.Singletons.Promote and Data.Singletons.Single (depending on the task-  at hand).+  derives SDecide, TestEquality, and TestCoercion instances. This additional+  complication makes Eq difficult to integrate with the other deriving+  machinery, so we handle it specially in Data.Singletons.Promote and+  Data.Singletons.Single (depending on the task at hand). * Deriving Show in singletons not only derives PShow/SShow instances, but it   also derives Show instances for singletons types. To make this work,   we let partitionDecs handle the PShow/SShow instances, but we also stick the
src/Data/Singletons/TH.hs view
@@ -42,13 +42,15 @@   -- ** Functions to generate 'Show' instances   promoteShowInstances, promoteShowInstance,   singShowInstances, singShowInstance,+  showSingInstances, showSingInstance,    -- ** Utility functions+  singITyConInstances, singITyConInstance,   cases, sCases,    -- * Basic singleton definitions-  Sing(SFalse, STrue, STuple0, STuple2, STuple3, STuple4, STuple5, STuple6, STuple7,-       SLT, SEQ, SGT),+  SBool(..), STuple0(..), STuple2(..), STuple3(..), STuple4(..),+  STuple5(..), STuple6(..), STuple7(..), SOrdering(..),   module Data.Singletons,    -- * Auxiliary definitions@@ -66,7 +68,7 @@   PFunctor(..), SFunctor(..),   PFoldable(..), SFoldable(..), PMonoid(..), SMonoid(..),   PTraversable(..), STraversable(..), PApplicative(..), SApplicative(..),-  (:.), (%.),+  type (.), (%.),   SomeSing(..),    Error, sError, ErrorSym0, ErrorSym1,@@ -189,4 +191,4 @@   where     conToPat :: (Name, Int) -> DPat     conToPat (name, num_fields) =-      DConPa name (replicate num_fields DWildPa)+      DConP name (replicate num_fields DWildP)
src/Data/Singletons/TypeError.hs view
@@ -1,4 +1,3 @@-{-# LANGUAGE AllowAmbiguousTypes #-} {-# LANGUAGE DataKinds #-} {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE FlexibleInstances #-}@@ -29,7 +28,7 @@ module Data.Singletons.TypeError (   TypeError, sTypeError, typeError,   ErrorMessage'(..), ErrorMessage, PErrorMessage,-  Sing(SText, SShowType, (:%<>:), (:%$$:)), SErrorMessage,+  Sing, SErrorMessage(..),   ConvertPErrorMessage, showErrorMessage,    -- * Defunctionalization symbols@@ -76,18 +75,15 @@ -- | A type-level `ErrorMessage'` which uses 'Symbol' as its text kind. type PErrorMessage = ErrorMessage' Symbol -data instance Sing :: PErrorMessage -> Type where-  -- It would be lovely to not have to write those (:: PErrorMessage) kind-  -- ascriptions in the return types of each constructor.-  -- See Trac #14111.-  SText     :: Sing t             -> Sing ('Text t      :: PErrorMessage)-  SShowType :: Sing ty            -> Sing ('ShowType ty :: PErrorMessage)-  (:%<>:)   :: Sing e1 -> Sing e2 -> Sing (e1 ':<>: e2  :: PErrorMessage)-  (:%$$:)   :: Sing e1 -> Sing e2 -> Sing (e1 ':$$: e2  :: PErrorMessage)+data SErrorMessage :: PErrorMessage -> Type where+  SText     :: Sing t             -> SErrorMessage ('Text t)+  SShowType :: Sing ty            -> SErrorMessage ('ShowType ty)+  (:%<>:)   :: Sing e1 -> Sing e2 -> SErrorMessage (e1 ':<>: e2)+  (:%$$:)   :: Sing e1 -> Sing e2 -> SErrorMessage (e1 ':$$: e2) infixl 6 :%<>: infixl 5 :%$$: -type SErrorMessage = (Sing :: PErrorMessage -> Type)+type instance Sing = SErrorMessage  instance SingKind PErrorMessage where   type Demote PErrorMessage = ErrorMessage@@ -158,30 +154,18 @@  instance SingI (TextSym0 :: Symbol ~> PErrorMessage) where   sing = singFun1 SText-instance SingI (TyCon1 'Text :: Symbol ~> PErrorMessage) where-  sing = singFun1 SText  instance SingI (ShowTypeSym0 :: t ~> PErrorMessage) where   sing = singFun1 SShowType-instance SingI (TyCon1 'ShowType :: t ~> PErrorMessage) where-  sing = singFun1 SShowType  instance SingI ((:<>:@#@$) :: PErrorMessage ~> PErrorMessage ~> PErrorMessage) where   sing = singFun2 (:%<>:)-instance SingI (TyCon2 '(:<>:) :: PErrorMessage ~> PErrorMessage ~> PErrorMessage) where-  sing = singFun2 (:%<>:) instance SingI x => SingI ((:<>:@#@$$) x :: PErrorMessage ~> PErrorMessage) where   sing = singFun1 (sing @x :%<>:)-instance SingI x => SingI (TyCon1 ('(:<>:) x) :: PErrorMessage ~> PErrorMessage) where-  sing = singFun1 (sing @x :%<>:)  instance SingI ((:$$:@#@$) :: PErrorMessage ~> PErrorMessage ~> PErrorMessage) where   sing = singFun2 (:%$$:)-instance SingI (TyCon2 '(:$$:) :: PErrorMessage ~> PErrorMessage ~> PErrorMessage) where-  sing = singFun2 (:%$$:) instance SingI x => SingI ((:$$:@#@$$) x :: PErrorMessage ~> PErrorMessage) where-  sing = singFun1 (sing @x :%$$:)-instance SingI x => SingI (TyCon1 ('(:$$:) x) :: PErrorMessage ~> PErrorMessage) where   sing = singFun1 (sing @x :%$$:)  instance SingI TypeErrorSym0 where
src/Data/Singletons/TypeLits.hs view
@@ -19,8 +19,7 @@  module Data.Singletons.TypeLits (   Nat, Symbol,-  Sing(SNat, SSym),-  SNat, SSymbol, withKnownNat, withKnownSymbol,+  Sing, SNat(..), SSymbol(..), withKnownNat, withKnownSymbol,   Error, sError,   ErrorWithoutStackTrace, sErrorWithoutStackTrace,   Undefined, sUndefined,
src/Data/Singletons/TypeLits/Internal.hs view
@@ -16,15 +16,14 @@ {-# LANGUAGE PolyKinds, DataKinds, TypeFamilies, FlexibleInstances,              UndecidableInstances, ScopedTypeVariables, RankNTypes,              GADTs, FlexibleContexts, TypeOperators, ConstraintKinds,-             TemplateHaskell, StandaloneDeriving,-             TypeApplications #-}+             TemplateHaskell, TypeApplications #-} {-# OPTIONS_GHC -Wno-orphans #-}  module Data.Singletons.TypeLits.Internal (-  Sing(..),+  Sing,    Nat, Symbol,-  SNat, SSymbol, withKnownNat, withKnownSymbol,+  SNat(..), SSymbol(..), withKnownNat, withKnownSymbol,   Error, sError,   ErrorWithoutStackTrace, sErrorWithoutStackTrace,   Undefined, sUndefined,@@ -49,7 +48,6 @@ import GHC.Stack (HasCallStack) import GHC.TypeLits as TL import qualified GHC.TypeNats as TN-import Data.Proxy ( Proxy(..) ) import Numeric.Natural (Natural) import Unsafe.Coerce @@ -60,7 +58,8 @@ ---- TypeLits singletons --------------------------------------------- ---------------------------------------------------------------------- -data instance Sing (n :: Nat) = KnownNat n => SNat+data SNat (n :: Nat) = KnownNat n => SNat+type instance Sing = SNat  instance KnownNat n => SingI n where   sing = SNat@@ -71,7 +70,8 @@   toSing n = case TN.someNatVal n of                SomeNat (_ :: Proxy n) -> SomeSing (SNat :: Sing n) -data instance Sing (n :: Symbol) = KnownSymbol n => SSym+data SSymbol (n :: Symbol) = KnownSymbol n => SSym+type instance Sing = SSymbol  instance KnownSymbol n => SingI n where   sing = SSym@@ -122,12 +122,6 @@  instance POrd Symbol where   type (a :: Symbol) `Compare` (b :: Symbol) = a `TL.CmpSymbol` b---- | Kind-restricted synonym for 'Sing' for @Nat@s-type SNat (x :: Nat) = Sing x---- | Kind-restricted synonym for 'Sing' for @Symbol@s-type SSymbol (x :: Symbol) = Sing x  -- SOrd instances instance SOrd Nat where
src/Data/Singletons/TypeRepTYPE.hs view
@@ -1,6 +1,6 @@ {-# LANGUAGE RankNTypes, TypeFamilies, FlexibleInstances,              GADTs, UndecidableInstances, ScopedTypeVariables,-             MagicHash, TypeOperators, PolyKinds #-}+             MagicHash, TypeOperators, PolyKinds, TypeApplications #-} {-# OPTIONS_GHC -Wno-orphans #-}  -----------------------------------------------------------------------------@@ -20,11 +20,10 @@ ----------------------------------------------------------------------------  module Data.Singletons.TypeRepTYPE (-  Sing(STypeRep),+  Sing,   -- | Here is the definition of the singleton for @'TYPE' rep@:   ---  -- > newtype instance Sing :: forall (rep :: RuntimeRep). TYPE rep -> Type where-  -- >   STypeRep :: forall (rep :: RuntimeRep) (a :: TYPE rep). TypeRep a -> Sing a+  -- > type instance Sing \@(TYPE rep) = TypeRep   --   -- Instances for 'SingI', 'SingKind', 'SEq', 'SDecide', and   -- 'TestCoercion' are also supplied.@@ -37,7 +36,6 @@ import Data.Singletons.Internal import Data.Singletons.Prelude.Eq import Data.Singletons.Decide-import Data.Type.Equality ((:~:)(..)) import GHC.Exts (RuntimeRep, TYPE) import Type.Reflection import Type.Reflection.Unsafe@@ -46,7 +44,7 @@ -- | A choice of singleton for the kind @'TYPE' rep@ (for some 'RuntimeRep' -- @rep@), an instantiation of which is the famous kind 'Type'. ----- Conceivably, one could generalize this instance to `Sing :: k -> Type` for+-- Conceivably, one could generalize this instance to `Sing \@k` for -- /any/ kind @k@, and remove all other 'Sing' instances. We don't adopt this -- design, however, since it is far more convenient in practice to work with -- explicit singleton values than 'TypeRep's (for instance, 'TypeRep's are@@ -55,9 +53,7 @@ -- We cannot produce explicit singleton values for everything in @'TYPE' rep@, -- however, since it is an open kind, so we reach for 'TypeRep' in this one -- particular case.-newtype instance Sing :: forall (rep :: RuntimeRep). TYPE rep -> Type where-  STypeRep :: forall (rep :: RuntimeRep) (a :: TYPE rep). TypeRep a -> Sing a-    deriving (Eq, Ord, Show)+type instance Sing @(TYPE rep) = TypeRep  -- | A variant of 'SomeTypeRep' whose underlying 'TypeRep' is restricted to -- kind @'TYPE' rep@ (for some 'RuntimeRep' @rep@).@@ -78,15 +74,15 @@   showsPrec p (SomeTypeRepTYPE ty) = showsPrec p ty  instance Typeable a => SingI (a :: TYPE rep) where-  sing = STypeRep typeRep+  sing = typeRep instance SingKind (TYPE rep) where   type Demote (TYPE rep) = SomeTypeRepTYPE rep-  fromSing (STypeRep tr) = SomeTypeRepTYPE tr-  toSing (SomeTypeRepTYPE tr) = SomeSing $ STypeRep tr+  fromSing = SomeTypeRepTYPE+  toSing (SomeTypeRepTYPE tr) = SomeSing tr  instance PEq (TYPE rep) instance SEq (TYPE rep) where-  STypeRep tra %== STypeRep trb =+  tra %== trb =     case eqTypeRep tra trb of       Just HRefl -> STrue       Nothing    -> unsafeCoerce SFalse@@ -94,7 +90,7 @@                     -- to enable us to define this without unsafeCoerce  instance SDecide (TYPE rep) where-  STypeRep tra %~ STypeRep trb =+  tra %~ trb =     case eqTypeRep tra trb of       Just HRefl -> Proved Refl       Nothing    -> Disproved (\Refl -> error "Type.Reflection.eqTypeRep failed")
src/Data/Singletons/Util.hs view
@@ -9,8 +9,7 @@  {-# LANGUAGE TypeSynonymInstances, FlexibleInstances, RankNTypes,              TemplateHaskell, GeneralizedNewtypeDeriving,-             MultiParamTypeClasses, StandaloneDeriving,-             UndecidableInstances, MagicHash, UnboxedTuples,+             MultiParamTypeClasses, UndecidableInstances, MagicHash,              LambdaCase, NoMonomorphismRestriction #-}  module Data.Singletons.Util where@@ -33,7 +32,6 @@ import Data.Generics import Data.Maybe import Data.Void-import Control.Monad.Fail ( MonadFail )  -- The list of types that singletons processes by default basicTypes :: [Name]@@ -92,7 +90,7 @@ qReportError = qReport True  -- | Generate a new Unique-qNewUnique :: DsMonad q => q Int+qNewUnique :: DsMonad q => q Uniq qNewUnique = do   Name _ flav <- qNewName "x"   case flav of@@ -203,7 +201,7 @@ -- convert a number into both alphanumeric and symoblic forms uniquePrefixes :: String   -- alphanumeric prefix                -> String   -- symbolic prefix-               -> Int+               -> Uniq                -> (String, String)  -- (alphanum, symbolic) uniquePrefixes alpha symb n = (alpha ++ n_str, symb ++ convert n_str)   where@@ -253,15 +251,6 @@ ravel []    res  = res ravel (h:t) res = DAppT (DAppT DArrowT h) (ravel t res) --- | Convert a 'DPred' to a 'DType'.-predToType :: DPred -> DType-predToType (DForallPr tvbs cxt p) = DForallT tvbs cxt (predToType p)-predToType (DAppPr p t)           = DAppT (predToType p) t-predToType (DSigPr p k)           = DSigT (predToType p) k-predToType (DVarPr n)             = DVarT n-predToType (DConPr n)             = DConT n-predToType DWildCardPr            = DWildCardT- -- count the number of arguments in a type countArgs :: DType -> Int countArgs ty = length args@@ -298,9 +287,10 @@   = DForallT tvbs' cxt' inner_ty'   where     (subst', tvbs') = mapAccumL subst_tvb subst tvbs-    cxt'            = map (substPred subst') cxt+    cxt'            = map (substType subst') cxt     inner_ty'       = substType subst' inner_ty substType subst (DAppT ty1 ty2) = substType subst ty1 `DAppT` substType subst ty2+substType subst (DAppKindT ty ki) = substType subst ty `DAppKindT` substType subst ki substType subst (DSigT ty ki) = substType subst ty `DSigT` substType subst ki substType subst (DVarT n) =   case Map.lookup n subst of@@ -311,22 +301,6 @@ substType _ ty@(DLitT {}) = ty substType _ ty@DWildCardT = ty -substPred :: Map Name DType -> DPred -> DPred-substPred subst pred | Map.null subst = pred-substPred subst (DForallPr tvbs cxt inner_pred)-  = DForallPr tvbs' cxt' inner_pred'-  where-    (subst', tvbs') = mapAccumL subst_tvb subst tvbs-    cxt'            = map (substPred subst') cxt-    inner_pred'     = substPred subst' inner_pred-substPred subst (DAppPr pred ty) =-  DAppPr (substPred subst pred) (substType subst ty)-substPred subst (DSigPr pred ki) =-  DSigPr (substPred subst pred) (substKind subst ki)-substPred _ pred@(DVarPr {}) = pred-substPred _ pred@(DConPr {}) = pred-substPred _ pred@DWildCardPr = pred- subst_tvb :: Map Name DKind -> DTyVarBndr -> (Map Name DKind, DTyVarBndr) subst_tvb s tvb@(DPlainTV n) = (Map.delete n s, tvb) subst_tvb s (DKindedTV n k)  = (Map.delete n s, DKindedTV n (substKind s k))@@ -342,34 +316,6 @@ -- apply a type to a list of type variable binders foldTypeTvbs :: DType -> [DTyVarBndr] -> DType foldTypeTvbs ty = foldType ty . map tvbToType---- apply a pred to a list of types-foldPred :: DPred -> [DType] -> DPred-foldPred = foldl DAppPr---- apply a pred to a list of type variable binders-foldPredTvbs :: DPred -> [DTyVarBndr] -> DPred-foldPredTvbs pr = foldPred pr . map tvbToType---- | Decompose an applied type into its individual components. For example, this:------ @--- Either Int Char--- @------ would be unfolded to this:------ @--- Either :| [Int, Char]--- @-unfoldType :: DType -> NonEmpty DType-unfoldType = go []-  where-    go :: [DType] -> DType -> NonEmpty DType-    go acc (DAppT t1 t2)    = go (t2:acc) t1-    go acc (DSigT t _)      = go acc t-    go acc (DForallT _ _ t) = go acc t-    go acc t                = t :| acc  -- Construct a data type's variable binders, possibly using fresh variables -- from the data type's kind signature.
tests/ByHand.hs view
@@ -15,7 +15,7 @@              RankNTypes, TypeOperators, MultiParamTypeClasses,              FunctionalDependencies, ScopedTypeVariables,              LambdaCase, TemplateHaskell, EmptyCase,-             AllowAmbiguousTypes, TypeApplications, EmptyCase+             TypeApplications, EmptyCase  #-}  module ByHand where@@ -88,9 +88,10 @@  -- Nat -data instance Sing :: Nat -> Type where-  SZero :: Sing Zero-  SSucc :: Sing n -> Sing (Succ n)+data SNat :: Nat -> Type where+  SZero :: SNat Zero+  SSucc :: SNat n -> SNat (Succ n)+type instance Sing = SNat  data SuccSym0 :: Nat ~> Nat type instance Apply SuccSym0 x = Succ x@@ -130,9 +131,10 @@  -- Bool -data instance Sing :: Bool -> Type where-  SFalse :: Sing False-  STrue :: Sing True+data SBool :: Bool -> Type where+  SFalse :: SBool False+  STrue :: SBool True+type instance Sing = SBool  (&&) :: Bool -> Bool -> Bool False && _ = False@@ -161,9 +163,10 @@  -- Maybe -data instance Sing :: Maybe k -> Type where-  SNothing :: Sing Nothing-  SJust :: forall k (a :: k). Sing a -> Sing (Just a)+data SMaybe :: forall k. Maybe k -> Type where+  SNothing :: SMaybe Nothing+  SJust :: forall k (a :: k). Sing a -> SMaybe (Just a)+type instance Sing = SMaybe  type family EqualsMaybe (a :: Maybe k) (b :: Maybe k) where   EqualsMaybe Nothing Nothing = True@@ -202,9 +205,10 @@  -- List -data instance Sing :: List k -> Type where-  SNil :: Sing Nil-  SCons :: forall k (h :: k) (t :: List k). Sing h -> Sing t -> Sing (Cons h t)+data SList :: forall k. List k -> Type where+  SNil :: SList Nil+  SCons :: forall k (h :: k) (t :: List k). Sing h -> SList t -> SList (Cons h t)+type instance Sing = SList  type NilSym0 = Nil @@ -256,9 +260,10 @@  -- Either -data instance Sing :: Either k1 k2 -> Type where-  SLeft :: forall k1 (a :: k1). Sing a -> Sing (Left a)-  SRight :: forall k2 (b :: k2). Sing b -> Sing (Right b)+data SEither :: forall k1 k2. Either k1 k2 -> Type where+  SLeft :: forall k1 (a :: k1). Sing a -> SEither (Left a)+  SRight :: forall k2 (b :: k2). Sing b -> SEither (Right b)+type instance Sing = SEither  instance (SingI a) => SingI (Left (a :: k)) where   sing = SLeft sing@@ -292,8 +297,9 @@ data Composite :: Type -> Type -> Type where   MkComp :: Either (Maybe a) b -> Composite a b -data instance Sing :: Composite k1 k2 -> Type where-  SMkComp :: forall k1 k2 (a :: Either (Maybe k1) k2). Sing a -> Sing (MkComp a)+data SComposite :: forall k1 k2. Composite k1 k2 -> Type where+  SMkComp :: forall k1 k2 (a :: Either (Maybe k1) k2). SEither a -> SComposite (MkComp a)+type instance Sing = SComposite  instance SingI a => SingI (MkComp (a :: Either (Maybe k1) k2)) where   sing = SMkComp sing@@ -314,7 +320,8 @@ -- Empty  data Empty-data instance Sing :: Empty -> Type+data SEmpty :: Empty -> Type+type instance Sing = SEmpty instance SingKind Empty where   type Demote Empty = Empty   fromSing = \case@@ -328,10 +335,11 @@  data Rep = Nat | Maybe Rep | Vec Rep Nat -data instance Sing :: Type -> Type where-  SNat :: Sing Nat-  SMaybe :: Sing a -> Sing (Maybe a)-  SVec :: Sing a -> Sing n -> Sing (Vec a n)+data SRep :: Type -> Type where+  SNat :: SRep Nat+  SMaybe :: SRep a -> SRep (Maybe a)+  SVec :: SRep a -> SNat n -> SRep (Vec a n)+type instance Sing = SRep  instance SingI Nat where   sing = SNat@@ -723,7 +731,7 @@ callImpNat :: forall n m. Sing n -> Sing m -> Sing (n + m) callImpNat sn sm = withSingI sn (impNat (Proxy :: Proxy n) sm) -instance Show (Sing (n :: Nat)) where+instance Show (SNat n) where   show SZero = "SZero"   show (SSucc n) = "SSucc (" ++ (show n) ++ ")" @@ -857,8 +865,9 @@  ------------------------------------------------------------ -data G a where+data G :: Type -> Type where   MkG :: G Bool -data instance Sing :: G a -> Type where-  SMkG :: Sing MkG+data SG :: forall a. G a -> Type where+  SMkG :: SG MkG+type instance Sing = SG
tests/ByHand2.hs view
@@ -31,13 +31,15 @@   Succ _ == Zero = False   Succ x == Succ y = x == y -data instance Sing :: Bool -> Type where-  SFalse :: Sing 'False-  STrue  :: Sing 'True+data SBool :: Bool -> Type where+  SFalse :: SBool 'False+  STrue  :: SBool 'True+type instance Sing = SBool -data instance Sing :: Nat -> Type where-  SZero :: Sing 'Zero-  SSucc :: Sing n -> Sing ('Succ n)+data SNat :: Nat -> Type where+  SZero :: SNat 'Zero+  SSucc :: SNat n -> SNat ('Succ n)+type instance Sing = SNat  type family Not (x :: Bool) :: Bool where   Not 'True = 'False@@ -112,10 +114,11 @@   type Compare ('Succ x) 'Zero     = 'GT   type Compare ('Succ x) ('Succ y) = Compare x y -data instance Sing :: Ordering -> Type where-  SLT :: Sing 'LT-  SEQ :: Sing 'EQ-  SGT :: Sing 'GT+data SOrdering :: Ordering -> Type where+  SLT :: SOrdering 'LT+  SEQ :: SOrdering 'EQ+  SGT :: SOrdering 'GT+type instance Sing = SOrdering  instance PEq Ordering where   type 'LT == 'LT = 'True
tests/SingletonsTestSuite.hs view
@@ -2,16 +2,13 @@     main  ) where -import Test.Tasty               ( TestTree, defaultMain, testGroup          )+import Test.Tasty               ( DependencyType(..), TestTree+                                , after, defaultMain, testGroup ) import SingletonsTestSuiteUtils ( compileAndDumpStdTest, compileAndDumpTest-                                , testCompileAndDumpGroup, ghcOpts-                             --   , cleanFiles-                                )+                                , testCompileAndDumpGroup, ghcOpts )  main :: IO ()-main = do---  cleanFiles    We really need to parallelize the testsuite.-  defaultMain tests+main = defaultMain tests  tests :: TestTree tests =@@ -21,29 +18,44 @@     , compileAndDumpStdTest "Empty"     , compileAndDumpStdTest "Maybe"     , compileAndDumpStdTest "BoxUnBox"-    , compileAndDumpStdTest "Operators"-    , compileAndDumpStdTest "HigherOrder"+    , afterSingletonsNat .+      compileAndDumpStdTest "Operators"+    , afterSingletonsNat .+      compileAndDumpStdTest "HigherOrder"     , compileAndDumpStdTest "Contains"-    , compileAndDumpStdTest "AsPattern"-    , compileAndDumpStdTest "DataValues"-    , compileAndDumpStdTest "EqInstances"+    , afterSingletonsNat .+      compileAndDumpStdTest "AsPattern"+    , afterSingletonsNat .+      compileAndDumpStdTest "DataValues"+    , after AllSucceed "$3 == \"Empty\"" .+      after AllSucceed "$3 == \"Operators\"" .+      compileAndDumpStdTest "EqInstances"     , compileAndDumpStdTest "CaseExpressions"-    , compileAndDumpStdTest "Star"-    , compileAndDumpStdTest "ReturnFunc"+    , afterSingletonsNat .+      compileAndDumpStdTest "Star"+    , afterSingletonsNat .+      compileAndDumpStdTest "ReturnFunc"     , compileAndDumpStdTest "Lambdas"-    , compileAndDumpStdTest "LambdasComprehensive"+    , afterSingletonsNat .+      compileAndDumpStdTest "LambdasComprehensive"     , compileAndDumpStdTest "Error"     , compileAndDumpStdTest "TopLevelPatterns"-    , compileAndDumpStdTest "LetStatements"+    , afterSingletonsNat .+      compileAndDumpStdTest "LetStatements"     , compileAndDumpStdTest "LambdaCase"-    , compileAndDumpStdTest "Sections"-    , compileAndDumpStdTest "PatternMatching"+    , afterSingletonsNat .+      compileAndDumpStdTest "Sections"+    , afterSingletonsNat .+      compileAndDumpStdTest "PatternMatching"     , compileAndDumpStdTest "Records"     , compileAndDumpStdTest "T29"     , compileAndDumpStdTest "T33"     , compileAndDumpStdTest "T54"-    , compileAndDumpStdTest "Classes"-    , compileAndDumpStdTest "Classes2"+    , afterSingletonsNat .+      compileAndDumpStdTest "Classes"+    , afterSingletonsNat .+      after AllSucceed "$3 == \"Classes\"" .+      compileAndDumpStdTest "Classes2"     , compileAndDumpStdTest "FunDeps"     , compileAndDumpStdTest "T78"     , compileAndDumpStdTest "OrdDeriving"@@ -102,12 +114,16 @@     , compileAndDumpStdTest "FunctorLikeDeriving"     , compileAndDumpStdTest "T353"     , compileAndDumpStdTest "T358"+    , compileAndDumpStdTest "T367"     , compileAndDumpStdTest "T371"+    , compileAndDumpStdTest "T376"+    , compileAndDumpStdTest "T402"     ],     testCompileAndDumpGroup "Promote"     [ compileAndDumpStdTest "Constructors"     , compileAndDumpStdTest "GenDefunSymbols"-    , compileAndDumpStdTest "Newtypes"+    , afterSingletonsNat .+      compileAndDumpStdTest "Newtypes"     , compileAndDumpStdTest "Pragmas"     , compileAndDumpStdTest "Prelude"     , compileAndDumpStdTest "T180"@@ -115,9 +131,13 @@     ],     testGroup "Database client"     [ compileAndDumpTest "GradingClient/Database" ghcOpts-    , compileAndDumpTest "GradingClient/Main"     ghcOpts+    , after AllSucceed "$3 == \"Database\"" $+      compileAndDumpTest "GradingClient/Main"     ghcOpts     ],     testCompileAndDumpGroup "InsertionSort"     [ compileAndDumpStdTest "InsertionSortImp"     ]   ]++afterSingletonsNat :: TestTree -> TestTree+afterSingletonsNat = after AllSucceed "$3 == \"Nat\""
tests/SingletonsTestSuiteUtils.hs view
@@ -2,6 +2,8 @@ {-# LANGUAGE DeriveAnyClass #-} {-# LANGUAGE DerivingStrategies #-} {-# LANGUAGE GeneralizedNewtypeDeriving #-}+{-# LANGUAGE OverloadedStrings #-}+{-# LANGUAGE TypeApplications #-} module SingletonsTestSuiteUtils (    compileAndDumpTest  , compileAndDumpStdTest@@ -12,7 +14,10 @@  import Build_singletons   ( ghcPath, ghcFlags, rootDir          ) import Control.Exception  ( Exception, throw                    )+import Data.Foldable      ( asum ) import Data.List          ( intercalate                         )+import Data.Text          ( Text                                )+import Data.String        ( IsString(fromString)                ) import System.Exit        ( ExitCode(..)                        ) import System.FilePath    ( takeBaseName, pathSeparator         ) import System.IO          ( IOMode(..), hGetContents, openFile  )@@ -22,6 +27,7 @@                           , callCommand                         ) import Test.Tasty         ( TestTree, testGroup                 ) import Test.Tasty.Golden  ( goldenVsFileDiff                    )+import qualified Turtle  -- Some infractructure for handling external process errors newtype ProcessException = ProcessException String@@ -33,7 +39,7 @@ goldenPath = rootDir </> "tests/compile-and-dump/"  ghcVersion :: String-ghcVersion = ".ghc86"+ghcVersion = ".ghc88"  -- GHC options used when running the tests ghcOpts :: [String]@@ -71,8 +77,8 @@   , "-XNoStarIsType"   ] --- Compile a test using specified GHC options. Save output to file, filter with--- sed and compare it with golden file. This function also builds golden file+-- Compile a test using specified GHC options. Save output to file, normalize+-- and compare it with golden file. This function also builds golden file -- from a template file. Putting it here is a bit of a hack but it's easy and it -- works. --@@ -100,7 +106,7 @@                                               , std_err = UseHandle hActualFile                                               , cwd     = Just goldenPath }       _ <- waitForProcess pid      -- see Note [Ignore exit code]-      filterWithSed actualFilePath -- see Note [Normalization with sed]+      normalizeOutput actualFilePath -- see Note [Output normalization]       buildGoldenFile templateFilePath goldenFilePath       return () @@ -137,10 +143,10 @@ --  -w - Ignore all white space. --  -B - Ignore changes whose lines are all blank. --- Note [Normalization with sed]+-- Note [Output normalization] -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ ----- Output file is normalized with sed. Line numbers generated in splices:+-- Output file is normalized inplace. Line numbers generated in splices: -- --   Foo:(40,3)-(42,4) --   Foo.hs:7:3:@@ -155,29 +161,27 @@ -- This allows to insert comments into test file without the need to modify the -- golden file to adjust line numbers. ----- Note that GNU sed (on Linux) and BSD sed (on MacOS) are slightly different.--- We use conditional compilation to deal with this. -filterWithSed :: FilePath -> IO ()-filterWithSed file = runProcessWithOpts CreatePipe "sed"-#ifdef darwin_HOST_OS-  [ "-i", "''"-#else-  [ "-i"-#endif-  , "-e", "'s/([0-9]*,[0-9]*)-([0-9]*,[0-9]*)/(0,0)-(0,0)/g'"-  , "-e", "'s/:[0-9][0-9]*:[0-9][0-9]*/:0:0/g'"-  , "-e", "'s/:[0-9]*:[0-9]*-[0-9]*/:0:0:/g'"-  , "-e", "'s/[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/0123456789/g'"-  , "-e", "'s/[0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9][0-9]/0123456789876543210/g'"-  , "-e", "'s/[!#$%&*+./>]\\{10\\}/%%%%%%%%%%/g'"-  , "-e", "'s/[!#$%&*+./>]\\{19\\}/%%%%%%%%%%%%%%%%%%%/g'"-    -- Remove pretty-printed references to the singletons package-    -- (e.g., turn `singletons-2.4.1:Sing` into `Sing`) to make the output-    -- more stable.-  , "-e", "'s/singletons-[0-9]\\+\\(\\.[0-9]\\+\\)*://g'"-  , file-  ]+normalizeOutput :: FilePath -> IO ()+normalizeOutput file = Turtle.inplace pat (fromString file)+  where+    pat :: Turtle.Pattern Text+    pat = asum+      [ "(0,0)-(0,0)" <$ numPair <* "-" <* numPair+      , ":0:0:" <$ ":" <* d <* ":" <* d <* "-" <* d+      , ":0:0" <$ ":" <* d <* ":" <* d+      , fromString @Text . numPeriod <$> Turtle.lowerBounded 10 Turtle.digit+      , fromString @Text . ('%' <$) <$> Turtle.lowerBounded 10 punctSym+      -- Remove pretty-printed references to the singletons package+      -- (e.g., turn `singletons-2.4.1:Sing` into `Sing`) to make the output+      -- more stable.+      , "" <$ "singletons-" <* verNum <* ":"+      ]+    verNum = d `Turtle.sepBy` Turtle.char '.'+    numPair = () <$ "(" <* d <* "," <* d <* ")"+    punctSym = Turtle.oneOf "!#$%&*+./>"+    numPeriod = zipWith const (cycle "0123456789876543210")+    d = Turtle.some Turtle.digit  buildGoldenFile :: FilePath -> FilePath -> IO () buildGoldenFile templateFilePath goldenFilePath = do
− tests/compile-and-dump/GradingClient/Database.ghc86.template 
@@ -1,2610 +0,0 @@-GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Nat-            = Zero | Succ Nat-            deriving (Eq, Ord) |]-  ======>-    data Nat-      = Zero | Succ Nat-      deriving (Eq, Ord)-    type ZeroSym0 = Zero-    type SuccSym1 (t0123456789876543210 :: Nat) =-        Succ t0123456789876543210-    instance SuppressUnusedWarnings SuccSym0 where-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())-    data SuccSym0 :: (~>) Nat Nat-      where-        SuccSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>-                                 SuccSym0 t0123456789876543210-    type instance Apply SuccSym0 t0123456789876543210 = Succ t0123456789876543210-    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where-      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])-      Compare_0123456789876543210 Zero (Succ _) = LTSym0-      Compare_0123456789876543210 (Succ _) Zero = GTSym0-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd Nat where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Equals_0123456789876543210 (a :: Nat) (b :: Nat) :: Bool where-      Equals_0123456789876543210 Zero Zero = TrueSym0-      Equals_0123456789876543210 (Succ a) (Succ b) = (==) a b-      Equals_0123456789876543210 (_ :: Nat) (_ :: Nat) = FalseSym0-    instance PEq Nat where-      type (==) a b = Equals_0123456789876543210 a b-    data instance Sing :: Nat -> Type-      where-        SZero :: Sing Zero-        SSucc :: forall (n :: Nat). (Sing (n :: Nat)) -> Sing (Succ n)-    type SNat = (Sing :: Nat -> Type)-    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 SOrd Nat => SOrd Nat where-      sCompare ::-        forall (t1 :: Nat) (t2 :: Nat).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)-                                                 -> Type) t1) t2)-      sCompare SZero SZero-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            SNil-      sCompare-        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               SNil)-      sCompare SZero (SSucc _) = SLT-      sCompare (SSucc _) SZero = SGT-    instance SEq Nat => SEq Nat where-      (%==) SZero SZero = STrue-      (%==) SZero (SSucc _) = SFalse-      (%==) (SSucc _) SZero = SFalse-      (%==) (SSucc a) (SSucc b) = ((%==) a) b-    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 SingI Zero where-      sing = SZero-    instance SingI n => SingI (Succ (n :: Nat)) where-      sing = SSucc sing-    instance SingI (SuccSym0 :: (~>) Nat Nat) where-      sing = (singFun1 @SuccSym0) SSucc-    instance SingI (TyCon1 Succ :: (~>) Nat Nat) where-      sing = (singFun1 @(TyCon1 Succ)) 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 = BOOL-    type STRINGSym0 = STRING-    type NATSym0 = NAT-    type VECSym2 (t0123456789876543210 :: U) (t0123456789876543210 :: Nat) =-        VEC t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (VECSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) VECSym1KindInference) ())-    data VECSym1 (t0123456789876543210 :: U) :: (~>) Nat U-      where-        VECSym1KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (VECSym1 t0123456789876543210) arg) (VECSym2 t0123456789876543210 arg) =>-                                VECSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (VECSym1 t0123456789876543210) t0123456789876543210 = VEC t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings VECSym0 where-      suppressUnusedWarnings = snd (((,) VECSym0KindInference) ())-    data VECSym0 :: (~>) U ((~>) Nat U)-      where-        VECSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply VECSym0 arg) (VECSym1 arg) =>-                                VECSym0 t0123456789876543210-    type instance Apply VECSym0 t0123456789876543210 = VECSym1 t0123456789876543210-    type CASym0 = CA-    type CBSym0 = CB-    type CCSym0 = CC-    type CDSym0 = CD-    type CESym0 = CE-    type CFSym0 = CF-    type CGSym0 = CG-    type CHSym0 = CH-    type CISym0 = CI-    type CJSym0 = CJ-    type CKSym0 = CK-    type CLSym0 = CL-    type CMSym0 = CM-    type CNSym0 = CN-    type COSym0 = CO-    type CPSym0 = CP-    type CQSym0 = CQ-    type CRSym0 = CR-    type CSSym0 = CS-    type CTSym0 = CT-    type CUSym0 = CU-    type CVSym0 = CV-    type CWSym0 = CW-    type CXSym0 = CX-    type CYSym0 = CY-    type CZSym0 = CZ-    type AttrSym2 (t0123456789876543210 :: [AChar]) (t0123456789876543210 :: U) =-        Attr t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (AttrSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) AttrSym1KindInference) ())-    data AttrSym1 (t0123456789876543210 :: [AChar]) :: (~>) U Attribute-      where-        AttrSym1KindInference :: forall t0123456789876543210-                                        t0123456789876543210-                                        arg. SameKind (Apply (AttrSym1 t0123456789876543210) arg) (AttrSym2 t0123456789876543210 arg) =>-                                 AttrSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (AttrSym1 t0123456789876543210) t0123456789876543210 = Attr t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings AttrSym0 where-      suppressUnusedWarnings = snd (((,) AttrSym0KindInference) ())-    data AttrSym0 :: (~>) [AChar] ((~>) U Attribute)-      where-        AttrSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply AttrSym0 arg) (AttrSym1 arg) =>-                                 AttrSym0 t0123456789876543210-    type instance Apply AttrSym0 t0123456789876543210 = AttrSym1 t0123456789876543210-    type SchSym1 (t0123456789876543210 :: [Attribute]) =-        Sch t0123456789876543210-    instance SuppressUnusedWarnings SchSym0 where-      suppressUnusedWarnings = snd (((,) SchSym0KindInference) ())-    data SchSym0 :: (~>) [Attribute] Schema-      where-        SchSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply SchSym0 arg) (SchSym1 arg) =>-                                SchSym0 t0123456789876543210-    type instance Apply SchSym0 t0123456789876543210 = Sch t0123456789876543210-    type Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 =-        Let0123456789876543210Scrutinee_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym3 u0123456789876543210 name'0123456789876543210 name0123456789876543210) where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference :: forall name0123456789876543210-                                                                                       name'0123456789876543210-                                                                                       u0123456789876543210-                                                                                       attrs0123456789876543210-                                                                                       arg. 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 u0123456789876543210 name'0123456789876543210 name0123456789876543210) attrs0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 u0123456789876543210 name'0123456789876543210 name0123456789876543210 attrs0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name'0123456789876543210 name0123456789876543210) where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 u0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference :: forall name0123456789876543210-                                                                                       name'0123456789876543210-                                                                                       u0123456789876543210-                                                                                       arg. 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 name'0123456789876543210 name0123456789876543210) u0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym3 name'0123456789876543210 name0123456789876543210 u0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: forall name0123456789876543210-                                                                                       name'0123456789876543210-                                                                                       arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall name0123456789876543210-                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs where-      Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs = Apply (Apply (==@#@$) name) name'-    type family Case_0123456789876543210 name name' u attrs t where-      Case_0123456789876543210 name name' u attrs  'True = u-      Case_0123456789876543210 name name' u attrs  'False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs)-    type LookupSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) =-        Lookup a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (LookupSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) LookupSym1KindInference) ())-    data LookupSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema U-      where-        LookupSym1KindInference :: forall a0123456789876543210-                                          a0123456789876543210-                                          arg. SameKind (Apply (LookupSym1 a0123456789876543210) arg) (LookupSym2 a0123456789876543210 arg) =>-                                   LookupSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (LookupSym1 a0123456789876543210) a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings LookupSym0 where-      suppressUnusedWarnings = snd (((,) LookupSym0KindInference) ())-    data LookupSym0 :: (~>) [AChar] ((~>) Schema U)-      where-        LookupSym0KindInference :: forall a0123456789876543210-                                          arg. SameKind (Apply LookupSym0 arg) (LookupSym1 arg) =>-                                   LookupSym0 a0123456789876543210-    type instance Apply LookupSym0 a0123456789876543210 = LookupSym1 a0123456789876543210-    type OccursSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) =-        Occurs a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (OccursSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) OccursSym1KindInference) ())-    data OccursSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema Bool-      where-        OccursSym1KindInference :: forall a0123456789876543210-                                          a0123456789876543210-                                          arg. SameKind (Apply (OccursSym1 a0123456789876543210) arg) (OccursSym2 a0123456789876543210 arg) =>-                                   OccursSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (OccursSym1 a0123456789876543210) a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings OccursSym0 where-      suppressUnusedWarnings = snd (((,) OccursSym0KindInference) ())-    data OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)-      where-        OccursSym0KindInference :: forall a0123456789876543210-                                          arg. SameKind (Apply OccursSym0 arg) (OccursSym1 arg) =>-                                   OccursSym0 a0123456789876543210-    type instance Apply OccursSym0 a0123456789876543210 = OccursSym1 a0123456789876543210-    type AttrNotInSym2 (a0123456789876543210 :: Attribute) (a0123456789876543210 :: Schema) =-        AttrNotIn a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (AttrNotInSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) AttrNotInSym1KindInference) ())-    data AttrNotInSym1 (a0123456789876543210 :: Attribute) :: (~>) Schema Bool-      where-        AttrNotInSym1KindInference :: forall a0123456789876543210-                                             a0123456789876543210-                                             arg. SameKind (Apply (AttrNotInSym1 a0123456789876543210) arg) (AttrNotInSym2 a0123456789876543210 arg) =>-                                      AttrNotInSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (AttrNotInSym1 a0123456789876543210) a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings AttrNotInSym0 where-      suppressUnusedWarnings = snd (((,) AttrNotInSym0KindInference) ())-    data AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)-      where-        AttrNotInSym0KindInference :: forall a0123456789876543210-                                             arg. SameKind (Apply AttrNotInSym0 arg) (AttrNotInSym1 arg) =>-                                      AttrNotInSym0 a0123456789876543210-    type instance Apply AttrNotInSym0 a0123456789876543210 = AttrNotInSym1 a0123456789876543210-    type DisjointSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) =-        Disjoint a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (DisjointSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) DisjointSym1KindInference) ())-    data DisjointSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Bool-      where-        DisjointSym1KindInference :: forall a0123456789876543210-                                            a0123456789876543210-                                            arg. SameKind (Apply (DisjointSym1 a0123456789876543210) arg) (DisjointSym2 a0123456789876543210 arg) =>-                                     DisjointSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (DisjointSym1 a0123456789876543210) a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings DisjointSym0 where-      suppressUnusedWarnings = snd (((,) DisjointSym0KindInference) ())-    data DisjointSym0 :: (~>) Schema ((~>) Schema Bool)-      where-        DisjointSym0KindInference :: forall a0123456789876543210-                                            arg. SameKind (Apply DisjointSym0 arg) (DisjointSym1 arg) =>-                                     DisjointSym0 a0123456789876543210-    type instance Apply DisjointSym0 a0123456789876543210 = DisjointSym1 a0123456789876543210-    type AppendSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) =-        Append a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (AppendSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) AppendSym1KindInference) ())-    data AppendSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Schema-      where-        AppendSym1KindInference :: forall a0123456789876543210-                                          a0123456789876543210-                                          arg. SameKind (Apply (AppendSym1 a0123456789876543210) arg) (AppendSym2 a0123456789876543210 arg) =>-                                   AppendSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (AppendSym1 a0123456789876543210) a0123456789876543210 = Append a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings AppendSym0 where-      suppressUnusedWarnings = snd (((,) AppendSym0KindInference) ())-    data AppendSym0 :: (~>) Schema ((~>) Schema Schema)-      where-        AppendSym0KindInference :: forall a0123456789876543210-                                          arg. SameKind (Apply AppendSym0 arg) (AppendSym1 arg) =>-                                   AppendSym0 a0123456789876543210-    type instance Apply AppendSym0 a0123456789876543210 = AppendSym1 a0123456789876543210-    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 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 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 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 family Append (a :: Schema) (a :: Schema) :: Schema where-      Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (++@#@$) s1) s2)-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: U) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: U) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) U ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) U ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow U where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: AChar) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: AChar) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) AChar ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) AChar ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow AChar where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family Equals_0123456789876543210 (a :: U) (b :: U) :: Bool where-      Equals_0123456789876543210 BOOL BOOL = TrueSym0-      Equals_0123456789876543210 STRING STRING = TrueSym0-      Equals_0123456789876543210 NAT NAT = TrueSym0-      Equals_0123456789876543210 (VEC a a) (VEC b b) = (&&) ((==) a b) ((==) a b)-      Equals_0123456789876543210 (_ :: U) (_ :: U) = FalseSym0-    instance PEq U where-      type (==) a b = Equals_0123456789876543210 a b-    type family Equals_0123456789876543210 (a :: AChar) (b :: AChar) :: Bool where-      Equals_0123456789876543210 CA CA = TrueSym0-      Equals_0123456789876543210 CB CB = TrueSym0-      Equals_0123456789876543210 CC CC = TrueSym0-      Equals_0123456789876543210 CD CD = TrueSym0-      Equals_0123456789876543210 CE CE = TrueSym0-      Equals_0123456789876543210 CF CF = TrueSym0-      Equals_0123456789876543210 CG CG = TrueSym0-      Equals_0123456789876543210 CH CH = TrueSym0-      Equals_0123456789876543210 CI CI = TrueSym0-      Equals_0123456789876543210 CJ CJ = TrueSym0-      Equals_0123456789876543210 CK CK = TrueSym0-      Equals_0123456789876543210 CL CL = TrueSym0-      Equals_0123456789876543210 CM CM = TrueSym0-      Equals_0123456789876543210 CN CN = TrueSym0-      Equals_0123456789876543210 CO CO = TrueSym0-      Equals_0123456789876543210 CP CP = TrueSym0-      Equals_0123456789876543210 CQ CQ = TrueSym0-      Equals_0123456789876543210 CR CR = TrueSym0-      Equals_0123456789876543210 CS CS = TrueSym0-      Equals_0123456789876543210 CT CT = TrueSym0-      Equals_0123456789876543210 CU CU = TrueSym0-      Equals_0123456789876543210 CV CV = TrueSym0-      Equals_0123456789876543210 CW CW = TrueSym0-      Equals_0123456789876543210 CX CX = TrueSym0-      Equals_0123456789876543210 CY CY = TrueSym0-      Equals_0123456789876543210 CZ CZ = TrueSym0-      Equals_0123456789876543210 (_ :: AChar) (_ :: AChar) = FalseSym0-    instance PEq AChar where-      type (==) a b = Equals_0123456789876543210 a b-    sLookup ::-      forall (t :: [AChar]) (t :: Schema).-      Sing t -> Sing t -> Sing (Apply (Apply LookupSym0 t) t :: U)-    sOccurs ::-      forall (t :: [AChar]) (t :: Schema).-      Sing t -> Sing t -> Sing (Apply (Apply OccursSym0 t) t :: Bool)-    sAttrNotIn ::-      forall (t :: Attribute) (t :: Schema).-      Sing t -> Sing t -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool)-    sDisjoint ::-      forall (t :: Schema) (t :: Schema).-      Sing t -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t :: Bool)-    sAppend ::-      forall (t :: Schema) (t :: Schema).-      Sing t -> Sing t -> Sing (Apply (Apply AppendSym0 t) t :: Schema)-    sLookup _ (SSch SNil) = sUndefined-    sLookup-      (sName :: Sing name)-      (SSch (SCons (SAttr (sName' :: Sing name') (sU :: Sing u))-                   (sAttrs :: Sing attrs)))-      = let-          sScrutinee_0123456789876543210 ::-            Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs)-          sScrutinee_0123456789876543210-            = (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName))-                sName'-        in  (case sScrutinee_0123456789876543210 of-               STrue -> sU-               SFalse-                 -> (applySing ((applySing ((singFun2 @LookupSym0) sLookup)) sName))-                      ((applySing ((singFun1 @SchSym0) SSch)) sAttrs)) ::-              Sing (Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) :: U)-    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))-    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))-    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)-    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 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 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 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 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))-    data instance Sing :: U -> Type-      where-        SBOOL :: Sing BOOL-        SSTRING :: Sing STRING-        SNAT :: Sing NAT-        SVEC :: forall (n :: U) (n :: Nat).-                (Sing (n :: U)) -> (Sing (n :: Nat)) -> Sing (VEC n n)-    type SU = (Sing :: U -> Type)-    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 instance Sing :: AChar -> Type-      where-        SCA :: Sing CA-        SCB :: Sing CB-        SCC :: Sing CC-        SCD :: Sing CD-        SCE :: Sing CE-        SCF :: Sing CF-        SCG :: Sing CG-        SCH :: Sing CH-        SCI :: Sing CI-        SCJ :: Sing CJ-        SCK :: Sing CK-        SCL :: Sing CL-        SCM :: Sing CM-        SCN :: Sing CN-        SCO :: Sing CO-        SCP :: Sing CP-        SCQ :: Sing CQ-        SCR :: Sing CR-        SCS :: Sing CS-        SCT :: Sing CT-        SCU :: Sing CU-        SCV :: Sing CV-        SCW :: Sing CW-        SCX :: Sing CX-        SCY :: Sing CY-        SCZ :: Sing CZ-    type SAChar = (Sing :: AChar -> Type)-    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 instance Sing :: Attribute -> Type-      where-        SAttr :: forall (n :: [AChar]) (n :: U).-                 (Sing (n :: [AChar])) -> (Sing (n :: U)) -> Sing (Attr n n)-    type SAttribute = (Sing :: Attribute -> Type)-    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 instance Sing :: Schema -> Type-      where-        SSch :: forall (n :: [Attribute]).-                (Sing (n :: [Attribute])) -> Sing (Sch n)-    type SSchema = (Sing :: Schema -> Type)-    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 (SShow U, SShow Nat) => SShow U where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: U) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) 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.Types.Nat) (t2 :: AChar) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) 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 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 a a) (SVEC b b) = ((%&&) (((%==) a) b)) (((%==) a) b)-    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 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 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-    deriving instance (Data.Singletons.ShowSing.ShowSing U,-                       Data.Singletons.ShowSing.ShowSing Nat) =>-                      Show (Sing (z :: U))-    deriving instance Show (Sing (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 (VECSym0 :: (~>) U ((~>) Nat U)) where-      sing = (singFun2 @VECSym0) SVEC-    instance SingI (TyCon2 VEC :: (~>) U ((~>) Nat U)) where-      sing = (singFun2 @(TyCon2 VEC)) SVEC-    instance SingI d => SingI (VECSym1 (d :: U) :: (~>) Nat U) where-      sing = (singFun1 @(VECSym1 (d :: U))) (SVEC (sing @d))-    instance SingI d =>-             SingI (TyCon1 (VEC (d :: U)) :: (~>) Nat U) where-      sing = (singFun1 @(TyCon1 (VEC (d :: U)))) (SVEC (sing @d))-    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 (AttrSym0 :: (~>) [AChar] ((~>) U Attribute)) where-      sing = (singFun2 @AttrSym0) SAttr-    instance SingI (TyCon2 Attr :: (~>) [AChar] ((~>) U Attribute)) where-      sing = (singFun2 @(TyCon2 Attr)) SAttr-    instance SingI d =>-             SingI (AttrSym1 (d :: [AChar]) :: (~>) U Attribute) where-      sing = (singFun1 @(AttrSym1 (d :: [AChar]))) (SAttr (sing @d))-    instance SingI d =>-             SingI (TyCon1 (Attr (d :: [AChar])) :: (~>) U Attribute) where-      sing = (singFun1 @(TyCon1 (Attr (d :: [AChar])))) (SAttr (sing @d))-    instance SingI n => SingI (Sch (n :: [Attribute])) where-      sing = SSch sing-    instance SingI (SchSym0 :: (~>) [Attribute] Schema) where-      sing = (singFun1 @SchSym0) SSch-    instance SingI (TyCon1 Sch :: (~>) [Attribute] Schema) where-      sing = (singFun1 @(TyCon1 Sch)) 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
+ tests/compile-and-dump/GradingClient/Database.ghc88.template view
@@ -0,0 +1,2663 @@+GradingClient/Database.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Nat+            = Zero | Succ Nat+            deriving (Eq, Ord) |]+  ======>+    data Nat+      = Zero | Succ Nat+      deriving (Eq, Ord)+    type ZeroSym0 = Zero+    type SuccSym1 (t0123456789876543210 :: Nat) =+        Succ t0123456789876543210+    instance SuppressUnusedWarnings SuccSym0 where+      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())+    data SuccSym0 :: (~>) Nat Nat+      where+        SuccSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>+                                 SuccSym0 t0123456789876543210+    type instance Apply SuccSym0 t0123456789876543210 = Succ t0123456789876543210+    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where+      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])+      Compare_0123456789876543210 Zero (Succ _) = LTSym0+      Compare_0123456789876543210 (Succ _) Zero = GTSym0+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd Nat where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family Equals_0123456789876543210 (a :: Nat) (b :: Nat) :: Bool where+      Equals_0123456789876543210 Zero Zero = TrueSym0+      Equals_0123456789876543210 (Succ a) (Succ b) = (==) a b+      Equals_0123456789876543210 (_ :: Nat) (_ :: Nat) = FalseSym0+    instance PEq Nat where+      type (==) a b = Equals_0123456789876543210 a b+    data SNat :: Nat -> Type+      where+        SZero :: SNat Zero+        SSucc :: forall (n :: Nat). (Sing (n :: Nat)) -> SNat (Succ n)+    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 SOrd Nat => SOrd Nat where+      sCompare ::+        forall (t1 :: Nat) (t2 :: Nat).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)+                                                 -> Type) t1) t2)+      sCompare SZero SZero+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            SNil+      sCompare+        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               SNil)+      sCompare SZero (SSucc _) = SLT+      sCompare (SSucc _) SZero = SGT+    instance SEq Nat => SEq Nat where+      (%==) SZero SZero = STrue+      (%==) SZero (SSucc _) = SFalse+      (%==) (SSucc _) SZero = SFalse+      (%==) (SSucc a) (SSucc b) = ((%==) a) b+    instance SDecide Nat => SDecide Nat where+      (%~) SZero SZero = Proved Refl+      (%~) SZero (SSucc _) = Disproved (\ x -> case x of)+      (%~) (SSucc _) SZero = Disproved (\ x -> case x of)+      (%~) (SSucc a) (SSucc b)+        = case ((%~) a) b of+            Proved Refl -> Proved Refl+            Disproved contra+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+    instance SDecide Nat =>+             Data.Type.Equality.TestEquality (SNat :: Nat -> Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance SDecide Nat =>+             Data.Type.Coercion.TestCoercion (SNat :: Nat -> Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance SingI Zero where+      sing = SZero+    instance SingI n => SingI (Succ (n :: Nat)) where+      sing = SSucc sing+    instance 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 = BOOL+    type STRINGSym0 = STRING+    type NATSym0 = NAT+    type VECSym2 (t0123456789876543210 :: U) (t0123456789876543210 :: Nat) =+        VEC t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (VECSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) VECSym1KindInference) ())+    data VECSym1 (t0123456789876543210 :: U) :: (~>) Nat U+      where+        VECSym1KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (VECSym1 t0123456789876543210) arg) (VECSym2 t0123456789876543210 arg) =>+                                VECSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (VECSym1 t0123456789876543210) t0123456789876543210 = VEC t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings VECSym0 where+      suppressUnusedWarnings = snd (((,) VECSym0KindInference) ())+    data VECSym0 :: (~>) U ((~>) Nat U)+      where+        VECSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply VECSym0 arg) (VECSym1 arg) =>+                                VECSym0 t0123456789876543210+    type instance Apply VECSym0 t0123456789876543210 = VECSym1 t0123456789876543210+    type CASym0 = CA+    type CBSym0 = CB+    type CCSym0 = CC+    type CDSym0 = CD+    type CESym0 = CE+    type CFSym0 = CF+    type CGSym0 = CG+    type CHSym0 = CH+    type CISym0 = CI+    type CJSym0 = CJ+    type CKSym0 = CK+    type CLSym0 = CL+    type CMSym0 = CM+    type CNSym0 = CN+    type COSym0 = CO+    type CPSym0 = CP+    type CQSym0 = CQ+    type CRSym0 = CR+    type CSSym0 = CS+    type CTSym0 = CT+    type CUSym0 = CU+    type CVSym0 = CV+    type CWSym0 = CW+    type CXSym0 = CX+    type CYSym0 = CY+    type CZSym0 = CZ+    type AttrSym2 (t0123456789876543210 :: [AChar]) (t0123456789876543210 :: U) =+        Attr t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (AttrSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) AttrSym1KindInference) ())+    data AttrSym1 (t0123456789876543210 :: [AChar]) :: (~>) U Attribute+      where+        AttrSym1KindInference :: forall t0123456789876543210+                                        t0123456789876543210+                                        arg. SameKind (Apply (AttrSym1 t0123456789876543210) arg) (AttrSym2 t0123456789876543210 arg) =>+                                 AttrSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (AttrSym1 t0123456789876543210) t0123456789876543210 = Attr t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings AttrSym0 where+      suppressUnusedWarnings = snd (((,) AttrSym0KindInference) ())+    data AttrSym0 :: (~>) [AChar] ((~>) U Attribute)+      where+        AttrSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply AttrSym0 arg) (AttrSym1 arg) =>+                                 AttrSym0 t0123456789876543210+    type instance Apply AttrSym0 t0123456789876543210 = AttrSym1 t0123456789876543210+    type SchSym1 (t0123456789876543210 :: [Attribute]) =+        Sch t0123456789876543210+    instance SuppressUnusedWarnings SchSym0 where+      suppressUnusedWarnings = snd (((,) SchSym0KindInference) ())+    data SchSym0 :: (~>) [Attribute] Schema+      where+        SchSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply SchSym0 arg) (SchSym1 arg) =>+                                SchSym0 t0123456789876543210+    type instance Apply SchSym0 t0123456789876543210 = Sch t0123456789876543210+    type Let0123456789876543210Scrutinee_0123456789876543210Sym4 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210 =+        Let0123456789876543210Scrutinee_0123456789876543210 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym3 u0123456789876543210 name'0123456789876543210 name0123456789876543210) where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym3 name0123456789876543210 name'0123456789876543210 u0123456789876543210 attrs0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym3KindInference :: forall name0123456789876543210+                                                                                       name'0123456789876543210+                                                                                       u0123456789876543210+                                                                                       attrs0123456789876543210+                                                                                       arg. 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 u0123456789876543210 name'0123456789876543210 name0123456789876543210) attrs0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 u0123456789876543210 name'0123456789876543210 name0123456789876543210 attrs0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym2 name'0123456789876543210 name0123456789876543210) where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym2 name0123456789876543210 name'0123456789876543210 u0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference :: forall name0123456789876543210+                                                                                       name'0123456789876543210+                                                                                       u0123456789876543210+                                                                                       arg. 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 name'0123456789876543210 name0123456789876543210) u0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym3 name'0123456789876543210 name0123456789876543210 u0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210) where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210 name'0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: forall name0123456789876543210+                                                                                       name'0123456789876543210+                                                                                       arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall name0123456789876543210+                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210+    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 name0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 name0123456789876543210+    type family Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs where+      Let0123456789876543210Scrutinee_0123456789876543210 name name' u attrs = Apply (Apply (==@#@$) name) name'+    type family Case_0123456789876543210 name name' u attrs t where+      Case_0123456789876543210 name name' u attrs 'True = u+      Case_0123456789876543210 name name' u attrs 'False = Apply (Apply LookupSym0 name) (Apply SchSym0 attrs)+    type LookupSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) =+        Lookup a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (LookupSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) LookupSym1KindInference) ())+    data LookupSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema U+      where+        LookupSym1KindInference :: forall a0123456789876543210+                                          a0123456789876543210+                                          arg. SameKind (Apply (LookupSym1 a0123456789876543210) arg) (LookupSym2 a0123456789876543210 arg) =>+                                   LookupSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (LookupSym1 a0123456789876543210) a0123456789876543210 = Lookup a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings LookupSym0 where+      suppressUnusedWarnings = snd (((,) LookupSym0KindInference) ())+    data LookupSym0 :: (~>) [AChar] ((~>) Schema U)+      where+        LookupSym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply LookupSym0 arg) (LookupSym1 arg) =>+                                   LookupSym0 a0123456789876543210+    type instance Apply LookupSym0 a0123456789876543210 = LookupSym1 a0123456789876543210+    type OccursSym2 (a0123456789876543210 :: [AChar]) (a0123456789876543210 :: Schema) =+        Occurs a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (OccursSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) OccursSym1KindInference) ())+    data OccursSym1 (a0123456789876543210 :: [AChar]) :: (~>) Schema Bool+      where+        OccursSym1KindInference :: forall a0123456789876543210+                                          a0123456789876543210+                                          arg. SameKind (Apply (OccursSym1 a0123456789876543210) arg) (OccursSym2 a0123456789876543210 arg) =>+                                   OccursSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (OccursSym1 a0123456789876543210) a0123456789876543210 = Occurs a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings OccursSym0 where+      suppressUnusedWarnings = snd (((,) OccursSym0KindInference) ())+    data OccursSym0 :: (~>) [AChar] ((~>) Schema Bool)+      where+        OccursSym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply OccursSym0 arg) (OccursSym1 arg) =>+                                   OccursSym0 a0123456789876543210+    type instance Apply OccursSym0 a0123456789876543210 = OccursSym1 a0123456789876543210+    type DisjointSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) =+        Disjoint a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (DisjointSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) DisjointSym1KindInference) ())+    data DisjointSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Bool+      where+        DisjointSym1KindInference :: forall a0123456789876543210+                                            a0123456789876543210+                                            arg. SameKind (Apply (DisjointSym1 a0123456789876543210) arg) (DisjointSym2 a0123456789876543210 arg) =>+                                     DisjointSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (DisjointSym1 a0123456789876543210) a0123456789876543210 = Disjoint a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings DisjointSym0 where+      suppressUnusedWarnings = snd (((,) DisjointSym0KindInference) ())+    data DisjointSym0 :: (~>) Schema ((~>) Schema Bool)+      where+        DisjointSym0KindInference :: forall a0123456789876543210+                                            arg. SameKind (Apply DisjointSym0 arg) (DisjointSym1 arg) =>+                                     DisjointSym0 a0123456789876543210+    type instance Apply DisjointSym0 a0123456789876543210 = DisjointSym1 a0123456789876543210+    type AttrNotInSym2 (a0123456789876543210 :: Attribute) (a0123456789876543210 :: Schema) =+        AttrNotIn a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (AttrNotInSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) AttrNotInSym1KindInference) ())+    data AttrNotInSym1 (a0123456789876543210 :: Attribute) :: (~>) Schema Bool+      where+        AttrNotInSym1KindInference :: forall a0123456789876543210+                                             a0123456789876543210+                                             arg. SameKind (Apply (AttrNotInSym1 a0123456789876543210) arg) (AttrNotInSym2 a0123456789876543210 arg) =>+                                      AttrNotInSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (AttrNotInSym1 a0123456789876543210) a0123456789876543210 = AttrNotIn a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings AttrNotInSym0 where+      suppressUnusedWarnings = snd (((,) AttrNotInSym0KindInference) ())+    data AttrNotInSym0 :: (~>) Attribute ((~>) Schema Bool)+      where+        AttrNotInSym0KindInference :: forall a0123456789876543210+                                             arg. SameKind (Apply AttrNotInSym0 arg) (AttrNotInSym1 arg) =>+                                      AttrNotInSym0 a0123456789876543210+    type instance Apply AttrNotInSym0 a0123456789876543210 = AttrNotInSym1 a0123456789876543210+    type AppendSym2 (a0123456789876543210 :: Schema) (a0123456789876543210 :: Schema) =+        Append a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (AppendSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) AppendSym1KindInference) ())+    data AppendSym1 (a0123456789876543210 :: Schema) :: (~>) Schema Schema+      where+        AppendSym1KindInference :: forall a0123456789876543210+                                          a0123456789876543210+                                          arg. SameKind (Apply (AppendSym1 a0123456789876543210) arg) (AppendSym2 a0123456789876543210 arg) =>+                                   AppendSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (AppendSym1 a0123456789876543210) a0123456789876543210 = Append a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings AppendSym0 where+      suppressUnusedWarnings = snd (((,) AppendSym0KindInference) ())+    data AppendSym0 :: (~>) Schema ((~>) Schema Schema)+      where+        AppendSym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply AppendSym0 arg) (AppendSym1 arg) =>+                                   AppendSym0 a0123456789876543210+    type instance Apply AppendSym0 a0123456789876543210 = AppendSym1 a0123456789876543210+    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 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 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 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 family Append (a :: Schema) (a :: Schema) :: Schema where+      Append (Sch s1) (Sch s2) = Apply SchSym0 (Apply (Apply (++@#@$) s1) s2)+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: U) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: U) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) U ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) U ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow U where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: AChar) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: AChar) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) AChar ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) AChar ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow AChar where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family Equals_0123456789876543210 (a :: U) (b :: U) :: Bool where+      Equals_0123456789876543210 BOOL BOOL = TrueSym0+      Equals_0123456789876543210 STRING STRING = TrueSym0+      Equals_0123456789876543210 NAT NAT = TrueSym0+      Equals_0123456789876543210 (VEC a a) (VEC b b) = (&&) ((==) a b) ((==) a b)+      Equals_0123456789876543210 (_ :: U) (_ :: U) = FalseSym0+    instance PEq U where+      type (==) a b = Equals_0123456789876543210 a b+    type family Equals_0123456789876543210 (a :: AChar) (b :: AChar) :: Bool where+      Equals_0123456789876543210 CA CA = TrueSym0+      Equals_0123456789876543210 CB CB = TrueSym0+      Equals_0123456789876543210 CC CC = TrueSym0+      Equals_0123456789876543210 CD CD = TrueSym0+      Equals_0123456789876543210 CE CE = TrueSym0+      Equals_0123456789876543210 CF CF = TrueSym0+      Equals_0123456789876543210 CG CG = TrueSym0+      Equals_0123456789876543210 CH CH = TrueSym0+      Equals_0123456789876543210 CI CI = TrueSym0+      Equals_0123456789876543210 CJ CJ = TrueSym0+      Equals_0123456789876543210 CK CK = TrueSym0+      Equals_0123456789876543210 CL CL = TrueSym0+      Equals_0123456789876543210 CM CM = TrueSym0+      Equals_0123456789876543210 CN CN = TrueSym0+      Equals_0123456789876543210 CO CO = TrueSym0+      Equals_0123456789876543210 CP CP = TrueSym0+      Equals_0123456789876543210 CQ CQ = TrueSym0+      Equals_0123456789876543210 CR CR = TrueSym0+      Equals_0123456789876543210 CS CS = TrueSym0+      Equals_0123456789876543210 CT CT = TrueSym0+      Equals_0123456789876543210 CU CU = TrueSym0+      Equals_0123456789876543210 CV CV = TrueSym0+      Equals_0123456789876543210 CW CW = TrueSym0+      Equals_0123456789876543210 CX CX = TrueSym0+      Equals_0123456789876543210 CY CY = TrueSym0+      Equals_0123456789876543210 CZ CZ = TrueSym0+      Equals_0123456789876543210 (_ :: AChar) (_ :: AChar) = FalseSym0+    instance PEq AChar where+      type (==) a b = Equals_0123456789876543210 a b+    sLookup ::+      forall (t :: [AChar]) (t :: Schema).+      Sing t -> Sing t -> Sing (Apply (Apply LookupSym0 t) t :: U)+    sOccurs ::+      forall (t :: [AChar]) (t :: Schema).+      Sing t -> Sing t -> Sing (Apply (Apply OccursSym0 t) t :: Bool)+    sDisjoint ::+      forall (t :: Schema) (t :: Schema).+      Sing t -> Sing t -> Sing (Apply (Apply DisjointSym0 t) t :: Bool)+    sAttrNotIn ::+      forall (t :: Attribute) (t :: Schema).+      Sing t -> Sing t -> Sing (Apply (Apply AttrNotInSym0 t) t :: Bool)+    sAppend ::+      forall (t :: Schema) (t :: Schema).+      Sing t -> Sing t -> Sing (Apply (Apply AppendSym0 t) t :: Schema)+    sLookup _ (SSch SNil) = sUndefined+    sLookup+      (sName :: Sing name)+      (SSch (SCons (SAttr (sName' :: Sing name') (sU :: Sing u))+                   (sAttrs :: Sing attrs)))+      = let+          sScrutinee_0123456789876543210 ::+            Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs)+          sScrutinee_0123456789876543210+            = (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName))+                sName'+        in+          (GHC.Base.id+             @(Sing (Case_0123456789876543210 name name' u attrs (Let0123456789876543210Scrutinee_0123456789876543210Sym4 name name' u attrs) :: U)))+            (case sScrutinee_0123456789876543210 of+               STrue -> sU+               SFalse+                 -> (applySing ((applySing ((singFun2 @LookupSym0) sLookup)) sName))+                      ((applySing ((singFun1 @SchSym0) SSch)) sAttrs))+    sOccurs _ (SSch SNil) = SFalse+    sOccurs+      (sName :: Sing name)+      (SSch (SCons (SAttr (sName' :: Sing name') _)+                   (sAttrs :: Sing attrs)))+      = (applySing+           ((applySing ((singFun2 @(||@#@$)) (%||)))+              ((applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sName))+                 sName')))+          ((applySing ((applySing ((singFun2 @OccursSym0) sOccurs)) sName))+             ((applySing ((singFun1 @SchSym0) SSch)) sAttrs))+    sDisjoint (SSch SNil) _ = STrue+    sDisjoint+      (SSch (SCons (sH :: Sing h) (sT :: Sing t)))+      (sS :: Sing s)+      = (applySing+           ((applySing ((singFun2 @(&&@#@$)) (%&&)))+              ((applySing+                  ((applySing ((singFun2 @AttrNotInSym0) sAttrNotIn)) sH))+                 sS)))+          ((applySing+              ((applySing ((singFun2 @DisjointSym0) sDisjoint))+                 ((applySing ((singFun1 @SchSym0) SSch)) sT)))+             sS)+    sAttrNotIn _ (SSch SNil) = STrue+    sAttrNotIn+      (SAttr (sName :: Sing name) (sU :: Sing u))+      (SSch (SCons (SAttr (sName' :: Sing name') _) (sT :: Sing t)))+      = (applySing+           ((applySing ((singFun2 @(&&@#@$)) (%&&)))+              ((applySing ((applySing ((singFun2 @(/=@#@$)) (%/=))) sName))+                 sName')))+          ((applySing+              ((applySing ((singFun2 @AttrNotInSym0) sAttrNotIn))+                 ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sName)) sU)))+             ((applySing ((singFun1 @SchSym0) SSch)) sT))+    sAppend (SSch (sS1 :: Sing s1)) (SSch (sS2 :: Sing s2))+      = (applySing ((singFun1 @SchSym0) SSch))+          ((applySing ((applySing ((singFun2 @(++@#@$)) (%++))) sS1)) sS2)+    instance SingI (LookupSym0 :: (~>) [AChar] ((~>) Schema U)) where+      sing = (singFun2 @LookupSym0) sLookup+    instance SingI d =>+             SingI (LookupSym1 (d :: [AChar]) :: (~>) Schema U) where+      sing = (singFun1 @(LookupSym1 (d :: [AChar]))) (sLookup (sing @d))+    instance 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 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 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 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))+    data SU :: U -> Type+      where+        SBOOL :: SU BOOL+        SSTRING :: SU STRING+        SNAT :: SU NAT+        SVEC :: forall (n :: U) (n :: Nat).+                (Sing (n :: U)) -> (Sing (n :: Nat)) -> SU (VEC n n)+    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+        SCB :: SAChar CB+        SCC :: SAChar CC+        SCD :: SAChar CD+        SCE :: SAChar CE+        SCF :: SAChar CF+        SCG :: SAChar CG+        SCH :: SAChar CH+        SCI :: SAChar CI+        SCJ :: SAChar CJ+        SCK :: SAChar CK+        SCL :: SAChar CL+        SCM :: SAChar CM+        SCN :: SAChar CN+        SCO :: SAChar CO+        SCP :: SAChar CP+        SCQ :: SAChar CQ+        SCR :: SAChar CR+        SCS :: SAChar CS+        SCT :: SAChar CT+        SCU :: SAChar CU+        SCV :: SAChar CV+        SCW :: SAChar CW+        SCX :: SAChar CX+        SCY :: SAChar CY+        SCZ :: SAChar CZ+    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 :: [AChar])) -> (Sing (n :: U)) -> SAttribute (Attr n n)+    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 :: [Attribute])) -> SSchema (Sch n)+    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 (SShow U, SShow Nat) => SShow U where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: U) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) 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.Types.Nat) (t2 :: AChar) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) 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 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 a a) (SVEC b b) = ((%&&) (((%==) a) b)) (((%==) a) b)+    instance (SDecide U, SDecide Nat) => SDecide U where+      (%~) SBOOL SBOOL = Proved Refl+      (%~) SBOOL SSTRING = Disproved (\ x -> case x of)+      (%~) SBOOL SNAT = Disproved (\ x -> case x of)+      (%~) SBOOL (SVEC _ _) = Disproved (\ x -> case x of)+      (%~) SSTRING SBOOL = Disproved (\ x -> case x of)+      (%~) SSTRING SSTRING = Proved Refl+      (%~) SSTRING SNAT = Disproved (\ x -> case x of)+      (%~) SSTRING (SVEC _ _) = Disproved (\ x -> case x of)+      (%~) SNAT SBOOL = Disproved (\ x -> case x of)+      (%~) SNAT SSTRING = Disproved (\ x -> case x of)+      (%~) SNAT SNAT = Proved Refl+      (%~) SNAT (SVEC _ _) = Disproved (\ x -> case x of)+      (%~) (SVEC _ _) SBOOL = Disproved (\ x -> case x of)+      (%~) (SVEC _ _) SSTRING = Disproved (\ x -> case x of)+      (%~) (SVEC _ _) SNAT = Disproved (\ x -> case x of)+      (%~) (SVEC a a) (SVEC b b)+        = case ((,) (((%~) a) b)) (((%~) a) b) of+            (,) (Proved Refl) (Proved Refl) -> Proved Refl+            (,) (Disproved contra) _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,) _ (Disproved contra)+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+    instance (SDecide U, SDecide Nat) =>+             Data.Type.Equality.TestEquality (SU :: U -> Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance (SDecide U, SDecide Nat) =>+             Data.Type.Coercion.TestCoercion (SU :: U -> Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance 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 AChar where+      (%~) SCA SCA = Proved Refl+      (%~) SCA SCB = Disproved (\ x -> case x of)+      (%~) SCA SCC = Disproved (\ x -> case x of)+      (%~) SCA SCD = Disproved (\ x -> case x of)+      (%~) SCA SCE = Disproved (\ x -> case x of)+      (%~) SCA SCF = Disproved (\ x -> case x of)+      (%~) SCA SCG = Disproved (\ x -> case x of)+      (%~) SCA SCH = Disproved (\ x -> case x of)+      (%~) SCA SCI = Disproved (\ x -> case x of)+      (%~) SCA SCJ = Disproved (\ x -> case x of)+      (%~) SCA SCK = Disproved (\ x -> case x of)+      (%~) SCA SCL = Disproved (\ x -> case x of)+      (%~) SCA SCM = Disproved (\ x -> case x of)+      (%~) SCA SCN = Disproved (\ x -> case x of)+      (%~) SCA SCO = Disproved (\ x -> case x of)+      (%~) SCA SCP = Disproved (\ x -> case x of)+      (%~) SCA SCQ = Disproved (\ x -> case x of)+      (%~) SCA SCR = Disproved (\ x -> case x of)+      (%~) SCA SCS = Disproved (\ x -> case x of)+      (%~) SCA SCT = Disproved (\ x -> case x of)+      (%~) SCA SCU = Disproved (\ x -> case x of)+      (%~) SCA SCV = Disproved (\ x -> case x of)+      (%~) SCA SCW = Disproved (\ x -> case x of)+      (%~) SCA SCX = Disproved (\ x -> case x of)+      (%~) SCA SCY = Disproved (\ x -> case x of)+      (%~) SCA SCZ = Disproved (\ x -> case x of)+      (%~) SCB SCA = Disproved (\ x -> case x of)+      (%~) SCB SCB = Proved Refl+      (%~) SCB SCC = Disproved (\ x -> case x of)+      (%~) SCB SCD = Disproved (\ x -> case x of)+      (%~) SCB SCE = Disproved (\ x -> case x of)+      (%~) SCB SCF = Disproved (\ x -> case x of)+      (%~) SCB SCG = Disproved (\ x -> case x of)+      (%~) SCB SCH = Disproved (\ x -> case x of)+      (%~) SCB SCI = Disproved (\ x -> case x of)+      (%~) SCB SCJ = Disproved (\ x -> case x of)+      (%~) SCB SCK = Disproved (\ x -> case x of)+      (%~) SCB SCL = Disproved (\ x -> case x of)+      (%~) SCB SCM = Disproved (\ x -> case x of)+      (%~) SCB SCN = Disproved (\ x -> case x of)+      (%~) SCB SCO = Disproved (\ x -> case x of)+      (%~) SCB SCP = Disproved (\ x -> case x of)+      (%~) SCB SCQ = Disproved (\ x -> case x of)+      (%~) SCB SCR = Disproved (\ x -> case x of)+      (%~) SCB SCS = Disproved (\ x -> case x of)+      (%~) SCB SCT = Disproved (\ x -> case x of)+      (%~) SCB SCU = Disproved (\ x -> case x of)+      (%~) SCB SCV = Disproved (\ x -> case x of)+      (%~) SCB SCW = Disproved (\ x -> case x of)+      (%~) SCB SCX = Disproved (\ x -> case x of)+      (%~) SCB SCY = Disproved (\ x -> case x of)+      (%~) SCB SCZ = Disproved (\ x -> case x of)+      (%~) SCC SCA = Disproved (\ x -> case x of)+      (%~) SCC SCB = Disproved (\ x -> case x of)+      (%~) SCC SCC = Proved Refl+      (%~) SCC SCD = Disproved (\ x -> case x of)+      (%~) SCC SCE = Disproved (\ x -> case x of)+      (%~) SCC SCF = Disproved (\ x -> case x of)+      (%~) SCC SCG = Disproved (\ x -> case x of)+      (%~) SCC SCH = Disproved (\ x -> case x of)+      (%~) SCC SCI = Disproved (\ x -> case x of)+      (%~) SCC SCJ = Disproved (\ x -> case x of)+      (%~) SCC SCK = Disproved (\ x -> case x of)+      (%~) SCC SCL = Disproved (\ x -> case x of)+      (%~) SCC SCM = Disproved (\ x -> case x of)+      (%~) SCC SCN = Disproved (\ x -> case x of)+      (%~) SCC SCO = Disproved (\ x -> case x of)+      (%~) SCC SCP = Disproved (\ x -> case x of)+      (%~) SCC SCQ = Disproved (\ x -> case x of)+      (%~) SCC SCR = Disproved (\ x -> case x of)+      (%~) SCC SCS = Disproved (\ x -> case x of)+      (%~) SCC SCT = Disproved (\ x -> case x of)+      (%~) SCC SCU = Disproved (\ x -> case x of)+      (%~) SCC SCV = Disproved (\ x -> case x of)+      (%~) SCC SCW = Disproved (\ x -> case x of)+      (%~) SCC SCX = Disproved (\ x -> case x of)+      (%~) SCC SCY = Disproved (\ x -> case x of)+      (%~) SCC SCZ = Disproved (\ x -> case x of)+      (%~) SCD SCA = Disproved (\ x -> case x of)+      (%~) SCD SCB = Disproved (\ x -> case x of)+      (%~) SCD SCC = Disproved (\ x -> case x of)+      (%~) SCD SCD = Proved Refl+      (%~) SCD SCE = Disproved (\ x -> case x of)+      (%~) SCD SCF = Disproved (\ x -> case x of)+      (%~) SCD SCG = Disproved (\ x -> case x of)+      (%~) SCD SCH = Disproved (\ x -> case x of)+      (%~) SCD SCI = Disproved (\ x -> case x of)+      (%~) SCD SCJ = Disproved (\ x -> case x of)+      (%~) SCD SCK = Disproved (\ x -> case x of)+      (%~) SCD SCL = Disproved (\ x -> case x of)+      (%~) SCD SCM = Disproved (\ x -> case x of)+      (%~) SCD SCN = Disproved (\ x -> case x of)+      (%~) SCD SCO = Disproved (\ x -> case x of)+      (%~) SCD SCP = Disproved (\ x -> case x of)+      (%~) SCD SCQ = Disproved (\ x -> case x of)+      (%~) SCD SCR = Disproved (\ x -> case x of)+      (%~) SCD SCS = Disproved (\ x -> case x of)+      (%~) SCD SCT = Disproved (\ x -> case x of)+      (%~) SCD SCU = Disproved (\ x -> case x of)+      (%~) SCD SCV = Disproved (\ x -> case x of)+      (%~) SCD SCW = Disproved (\ x -> case x of)+      (%~) SCD SCX = Disproved (\ x -> case x of)+      (%~) SCD SCY = Disproved (\ x -> case x of)+      (%~) SCD SCZ = Disproved (\ x -> case x of)+      (%~) SCE SCA = Disproved (\ x -> case x of)+      (%~) SCE SCB = Disproved (\ x -> case x of)+      (%~) SCE SCC = Disproved (\ x -> case x of)+      (%~) SCE SCD = Disproved (\ x -> case x of)+      (%~) SCE SCE = Proved Refl+      (%~) SCE SCF = Disproved (\ x -> case x of)+      (%~) SCE SCG = Disproved (\ x -> case x of)+      (%~) SCE SCH = Disproved (\ x -> case x of)+      (%~) SCE SCI = Disproved (\ x -> case x of)+      (%~) SCE SCJ = Disproved (\ x -> case x of)+      (%~) SCE SCK = Disproved (\ x -> case x of)+      (%~) SCE SCL = Disproved (\ x -> case x of)+      (%~) SCE SCM = Disproved (\ x -> case x of)+      (%~) SCE SCN = Disproved (\ x -> case x of)+      (%~) SCE SCO = Disproved (\ x -> case x of)+      (%~) SCE SCP = Disproved (\ x -> case x of)+      (%~) SCE SCQ = Disproved (\ x -> case x of)+      (%~) SCE SCR = Disproved (\ x -> case x of)+      (%~) SCE SCS = Disproved (\ x -> case x of)+      (%~) SCE SCT = Disproved (\ x -> case x of)+      (%~) SCE SCU = Disproved (\ x -> case x of)+      (%~) SCE SCV = Disproved (\ x -> case x of)+      (%~) SCE SCW = Disproved (\ x -> case x of)+      (%~) SCE SCX = Disproved (\ x -> case x of)+      (%~) SCE SCY = Disproved (\ x -> case x of)+      (%~) SCE SCZ = Disproved (\ x -> case x of)+      (%~) SCF SCA = Disproved (\ x -> case x of)+      (%~) SCF SCB = Disproved (\ x -> case x of)+      (%~) SCF SCC = Disproved (\ x -> case x of)+      (%~) SCF SCD = Disproved (\ x -> case x of)+      (%~) SCF SCE = Disproved (\ x -> case x of)+      (%~) SCF SCF = Proved Refl+      (%~) SCF SCG = Disproved (\ x -> case x of)+      (%~) SCF SCH = Disproved (\ x -> case x of)+      (%~) SCF SCI = Disproved (\ x -> case x of)+      (%~) SCF SCJ = Disproved (\ x -> case x of)+      (%~) SCF SCK = Disproved (\ x -> case x of)+      (%~) SCF SCL = Disproved (\ x -> case x of)+      (%~) SCF SCM = Disproved (\ x -> case x of)+      (%~) SCF SCN = Disproved (\ x -> case x of)+      (%~) SCF SCO = Disproved (\ x -> case x of)+      (%~) SCF SCP = Disproved (\ x -> case x of)+      (%~) SCF SCQ = Disproved (\ x -> case x of)+      (%~) SCF SCR = Disproved (\ x -> case x of)+      (%~) SCF SCS = Disproved (\ x -> case x of)+      (%~) SCF SCT = Disproved (\ x -> case x of)+      (%~) SCF SCU = Disproved (\ x -> case x of)+      (%~) SCF SCV = Disproved (\ x -> case x of)+      (%~) SCF SCW = Disproved (\ x -> case x of)+      (%~) SCF SCX = Disproved (\ x -> case x of)+      (%~) SCF SCY = Disproved (\ x -> case x of)+      (%~) SCF SCZ = Disproved (\ x -> case x of)+      (%~) SCG SCA = Disproved (\ x -> case x of)+      (%~) SCG SCB = Disproved (\ x -> case x of)+      (%~) SCG SCC = Disproved (\ x -> case x of)+      (%~) SCG SCD = Disproved (\ x -> case x of)+      (%~) SCG SCE = Disproved (\ x -> case x of)+      (%~) SCG SCF = Disproved (\ x -> case x of)+      (%~) SCG SCG = Proved Refl+      (%~) SCG SCH = Disproved (\ x -> case x of)+      (%~) SCG SCI = Disproved (\ x -> case x of)+      (%~) SCG SCJ = Disproved (\ x -> case x of)+      (%~) SCG SCK = Disproved (\ x -> case x of)+      (%~) SCG SCL = Disproved (\ x -> case x of)+      (%~) SCG SCM = Disproved (\ x -> case x of)+      (%~) SCG SCN = Disproved (\ x -> case x of)+      (%~) SCG SCO = Disproved (\ x -> case x of)+      (%~) SCG SCP = Disproved (\ x -> case x of)+      (%~) SCG SCQ = Disproved (\ x -> case x of)+      (%~) SCG SCR = Disproved (\ x -> case x of)+      (%~) SCG SCS = Disproved (\ x -> case x of)+      (%~) SCG SCT = Disproved (\ x -> case x of)+      (%~) SCG SCU = Disproved (\ x -> case x of)+      (%~) SCG SCV = Disproved (\ x -> case x of)+      (%~) SCG SCW = Disproved (\ x -> case x of)+      (%~) SCG SCX = Disproved (\ x -> case x of)+      (%~) SCG SCY = Disproved (\ x -> case x of)+      (%~) SCG SCZ = Disproved (\ x -> case x of)+      (%~) SCH SCA = Disproved (\ x -> case x of)+      (%~) SCH SCB = Disproved (\ x -> case x of)+      (%~) SCH SCC = Disproved (\ x -> case x of)+      (%~) SCH SCD = Disproved (\ x -> case x of)+      (%~) SCH SCE = Disproved (\ x -> case x of)+      (%~) SCH SCF = Disproved (\ x -> case x of)+      (%~) SCH SCG = Disproved (\ x -> case x of)+      (%~) SCH SCH = Proved Refl+      (%~) SCH SCI = Disproved (\ x -> case x of)+      (%~) SCH SCJ = Disproved (\ x -> case x of)+      (%~) SCH SCK = Disproved (\ x -> case x of)+      (%~) SCH SCL = Disproved (\ x -> case x of)+      (%~) SCH SCM = Disproved (\ x -> case x of)+      (%~) SCH SCN = Disproved (\ x -> case x of)+      (%~) SCH SCO = Disproved (\ x -> case x of)+      (%~) SCH SCP = Disproved (\ x -> case x of)+      (%~) SCH SCQ = Disproved (\ x -> case x of)+      (%~) SCH SCR = Disproved (\ x -> case x of)+      (%~) SCH SCS = Disproved (\ x -> case x of)+      (%~) SCH SCT = Disproved (\ x -> case x of)+      (%~) SCH SCU = Disproved (\ x -> case x of)+      (%~) SCH SCV = Disproved (\ x -> case x of)+      (%~) SCH SCW = Disproved (\ x -> case x of)+      (%~) SCH SCX = Disproved (\ x -> case x of)+      (%~) SCH SCY = Disproved (\ x -> case x of)+      (%~) SCH SCZ = Disproved (\ x -> case x of)+      (%~) SCI SCA = Disproved (\ x -> case x of)+      (%~) SCI SCB = Disproved (\ x -> case x of)+      (%~) SCI SCC = Disproved (\ x -> case x of)+      (%~) SCI SCD = Disproved (\ x -> case x of)+      (%~) SCI SCE = Disproved (\ x -> case x of)+      (%~) SCI SCF = Disproved (\ x -> case x of)+      (%~) SCI SCG = Disproved (\ x -> case x of)+      (%~) SCI SCH = Disproved (\ x -> case x of)+      (%~) SCI SCI = Proved Refl+      (%~) SCI SCJ = Disproved (\ x -> case x of)+      (%~) SCI SCK = Disproved (\ x -> case x of)+      (%~) SCI SCL = Disproved (\ x -> case x of)+      (%~) SCI SCM = Disproved (\ x -> case x of)+      (%~) SCI SCN = Disproved (\ x -> case x of)+      (%~) SCI SCO = Disproved (\ x -> case x of)+      (%~) SCI SCP = Disproved (\ x -> case x of)+      (%~) SCI SCQ = Disproved (\ x -> case x of)+      (%~) SCI SCR = Disproved (\ x -> case x of)+      (%~) SCI SCS = Disproved (\ x -> case x of)+      (%~) SCI SCT = Disproved (\ x -> case x of)+      (%~) SCI SCU = Disproved (\ x -> case x of)+      (%~) SCI SCV = Disproved (\ x -> case x of)+      (%~) SCI SCW = Disproved (\ x -> case x of)+      (%~) SCI SCX = Disproved (\ x -> case x of)+      (%~) SCI SCY = Disproved (\ x -> case x of)+      (%~) SCI SCZ = Disproved (\ x -> case x of)+      (%~) SCJ SCA = Disproved (\ x -> case x of)+      (%~) SCJ SCB = Disproved (\ x -> case x of)+      (%~) SCJ SCC = Disproved (\ x -> case x of)+      (%~) SCJ SCD = Disproved (\ x -> case x of)+      (%~) SCJ SCE = Disproved (\ x -> case x of)+      (%~) SCJ SCF = Disproved (\ x -> case x of)+      (%~) SCJ SCG = Disproved (\ x -> case x of)+      (%~) SCJ SCH = Disproved (\ x -> case x of)+      (%~) SCJ SCI = Disproved (\ x -> case x of)+      (%~) SCJ SCJ = Proved Refl+      (%~) SCJ SCK = Disproved (\ x -> case x of)+      (%~) SCJ SCL = Disproved (\ x -> case x of)+      (%~) SCJ SCM = Disproved (\ x -> case x of)+      (%~) SCJ SCN = Disproved (\ x -> case x of)+      (%~) SCJ SCO = Disproved (\ x -> case x of)+      (%~) SCJ SCP = Disproved (\ x -> case x of)+      (%~) SCJ SCQ = Disproved (\ x -> case x of)+      (%~) SCJ SCR = Disproved (\ x -> case x of)+      (%~) SCJ SCS = Disproved (\ x -> case x of)+      (%~) SCJ SCT = Disproved (\ x -> case x of)+      (%~) SCJ SCU = Disproved (\ x -> case x of)+      (%~) SCJ SCV = Disproved (\ x -> case x of)+      (%~) SCJ SCW = Disproved (\ x -> case x of)+      (%~) SCJ SCX = Disproved (\ x -> case x of)+      (%~) SCJ SCY = Disproved (\ x -> case x of)+      (%~) SCJ SCZ = Disproved (\ x -> case x of)+      (%~) SCK SCA = Disproved (\ x -> case x of)+      (%~) SCK SCB = Disproved (\ x -> case x of)+      (%~) SCK SCC = Disproved (\ x -> case x of)+      (%~) SCK SCD = Disproved (\ x -> case x of)+      (%~) SCK SCE = Disproved (\ x -> case x of)+      (%~) SCK SCF = Disproved (\ x -> case x of)+      (%~) SCK SCG = Disproved (\ x -> case x of)+      (%~) SCK SCH = Disproved (\ x -> case x of)+      (%~) SCK SCI = Disproved (\ x -> case x of)+      (%~) SCK SCJ = Disproved (\ x -> case x of)+      (%~) SCK SCK = Proved Refl+      (%~) SCK SCL = Disproved (\ x -> case x of)+      (%~) SCK SCM = Disproved (\ x -> case x of)+      (%~) SCK SCN = Disproved (\ x -> case x of)+      (%~) SCK SCO = Disproved (\ x -> case x of)+      (%~) SCK SCP = Disproved (\ x -> case x of)+      (%~) SCK SCQ = Disproved (\ x -> case x of)+      (%~) SCK SCR = Disproved (\ x -> case x of)+      (%~) SCK SCS = Disproved (\ x -> case x of)+      (%~) SCK SCT = Disproved (\ x -> case x of)+      (%~) SCK SCU = Disproved (\ x -> case x of)+      (%~) SCK SCV = Disproved (\ x -> case x of)+      (%~) SCK SCW = Disproved (\ x -> case x of)+      (%~) SCK SCX = Disproved (\ x -> case x of)+      (%~) SCK SCY = Disproved (\ x -> case x of)+      (%~) SCK SCZ = Disproved (\ x -> case x of)+      (%~) SCL SCA = Disproved (\ x -> case x of)+      (%~) SCL SCB = Disproved (\ x -> case x of)+      (%~) SCL SCC = Disproved (\ x -> case x of)+      (%~) SCL SCD = Disproved (\ x -> case x of)+      (%~) SCL SCE = Disproved (\ x -> case x of)+      (%~) SCL SCF = Disproved (\ x -> case x of)+      (%~) SCL SCG = Disproved (\ x -> case x of)+      (%~) SCL SCH = Disproved (\ x -> case x of)+      (%~) SCL SCI = Disproved (\ x -> case x of)+      (%~) SCL SCJ = Disproved (\ x -> case x of)+      (%~) SCL SCK = Disproved (\ x -> case x of)+      (%~) SCL SCL = Proved Refl+      (%~) SCL SCM = Disproved (\ x -> case x of)+      (%~) SCL SCN = Disproved (\ x -> case x of)+      (%~) SCL SCO = Disproved (\ x -> case x of)+      (%~) SCL SCP = Disproved (\ x -> case x of)+      (%~) SCL SCQ = Disproved (\ x -> case x of)+      (%~) SCL SCR = Disproved (\ x -> case x of)+      (%~) SCL SCS = Disproved (\ x -> case x of)+      (%~) SCL SCT = Disproved (\ x -> case x of)+      (%~) SCL SCU = Disproved (\ x -> case x of)+      (%~) SCL SCV = Disproved (\ x -> case x of)+      (%~) SCL SCW = Disproved (\ x -> case x of)+      (%~) SCL SCX = Disproved (\ x -> case x of)+      (%~) SCL SCY = Disproved (\ x -> case x of)+      (%~) SCL SCZ = Disproved (\ x -> case x of)+      (%~) SCM SCA = Disproved (\ x -> case x of)+      (%~) SCM SCB = Disproved (\ x -> case x of)+      (%~) SCM SCC = Disproved (\ x -> case x of)+      (%~) SCM SCD = Disproved (\ x -> case x of)+      (%~) SCM SCE = Disproved (\ x -> case x of)+      (%~) SCM SCF = Disproved (\ x -> case x of)+      (%~) SCM SCG = Disproved (\ x -> case x of)+      (%~) SCM SCH = Disproved (\ x -> case x of)+      (%~) SCM SCI = Disproved (\ x -> case x of)+      (%~) SCM SCJ = Disproved (\ x -> case x of)+      (%~) SCM SCK = Disproved (\ x -> case x of)+      (%~) SCM SCL = Disproved (\ x -> case x of)+      (%~) SCM SCM = Proved Refl+      (%~) SCM SCN = Disproved (\ x -> case x of)+      (%~) SCM SCO = Disproved (\ x -> case x of)+      (%~) SCM SCP = Disproved (\ x -> case x of)+      (%~) SCM SCQ = Disproved (\ x -> case x of)+      (%~) SCM SCR = Disproved (\ x -> case x of)+      (%~) SCM SCS = Disproved (\ x -> case x of)+      (%~) SCM SCT = Disproved (\ x -> case x of)+      (%~) SCM SCU = Disproved (\ x -> case x of)+      (%~) SCM SCV = Disproved (\ x -> case x of)+      (%~) SCM SCW = Disproved (\ x -> case x of)+      (%~) SCM SCX = Disproved (\ x -> case x of)+      (%~) SCM SCY = Disproved (\ x -> case x of)+      (%~) SCM SCZ = Disproved (\ x -> case x of)+      (%~) SCN SCA = Disproved (\ x -> case x of)+      (%~) SCN SCB = Disproved (\ x -> case x of)+      (%~) SCN SCC = Disproved (\ x -> case x of)+      (%~) SCN SCD = Disproved (\ x -> case x of)+      (%~) SCN SCE = Disproved (\ x -> case x of)+      (%~) SCN SCF = Disproved (\ x -> case x of)+      (%~) SCN SCG = Disproved (\ x -> case x of)+      (%~) SCN SCH = Disproved (\ x -> case x of)+      (%~) SCN SCI = Disproved (\ x -> case x of)+      (%~) SCN SCJ = Disproved (\ x -> case x of)+      (%~) SCN SCK = Disproved (\ x -> case x of)+      (%~) SCN SCL = Disproved (\ x -> case x of)+      (%~) SCN SCM = Disproved (\ x -> case x of)+      (%~) SCN SCN = Proved Refl+      (%~) SCN SCO = Disproved (\ x -> case x of)+      (%~) SCN SCP = Disproved (\ x -> case x of)+      (%~) SCN SCQ = Disproved (\ x -> case x of)+      (%~) SCN SCR = Disproved (\ x -> case x of)+      (%~) SCN SCS = Disproved (\ x -> case x of)+      (%~) SCN SCT = Disproved (\ x -> case x of)+      (%~) SCN SCU = Disproved (\ x -> case x of)+      (%~) SCN SCV = Disproved (\ x -> case x of)+      (%~) SCN SCW = Disproved (\ x -> case x of)+      (%~) SCN SCX = Disproved (\ x -> case x of)+      (%~) SCN SCY = Disproved (\ x -> case x of)+      (%~) SCN SCZ = Disproved (\ x -> case x of)+      (%~) SCO SCA = Disproved (\ x -> case x of)+      (%~) SCO SCB = Disproved (\ x -> case x of)+      (%~) SCO SCC = Disproved (\ x -> case x of)+      (%~) SCO SCD = Disproved (\ x -> case x of)+      (%~) SCO SCE = Disproved (\ x -> case x of)+      (%~) SCO SCF = Disproved (\ x -> case x of)+      (%~) SCO SCG = Disproved (\ x -> case x of)+      (%~) SCO SCH = Disproved (\ x -> case x of)+      (%~) SCO SCI = Disproved (\ x -> case x of)+      (%~) SCO SCJ = Disproved (\ x -> case x of)+      (%~) SCO SCK = Disproved (\ x -> case x of)+      (%~) SCO SCL = Disproved (\ x -> case x of)+      (%~) SCO SCM = Disproved (\ x -> case x of)+      (%~) SCO SCN = Disproved (\ x -> case x of)+      (%~) SCO SCO = Proved Refl+      (%~) SCO SCP = Disproved (\ x -> case x of)+      (%~) SCO SCQ = Disproved (\ x -> case x of)+      (%~) SCO SCR = Disproved (\ x -> case x of)+      (%~) SCO SCS = Disproved (\ x -> case x of)+      (%~) SCO SCT = Disproved (\ x -> case x of)+      (%~) SCO SCU = Disproved (\ x -> case x of)+      (%~) SCO SCV = Disproved (\ x -> case x of)+      (%~) SCO SCW = Disproved (\ x -> case x of)+      (%~) SCO SCX = Disproved (\ x -> case x of)+      (%~) SCO SCY = Disproved (\ x -> case x of)+      (%~) SCO SCZ = Disproved (\ x -> case x of)+      (%~) SCP SCA = Disproved (\ x -> case x of)+      (%~) SCP SCB = Disproved (\ x -> case x of)+      (%~) SCP SCC = Disproved (\ x -> case x of)+      (%~) SCP SCD = Disproved (\ x -> case x of)+      (%~) SCP SCE = Disproved (\ x -> case x of)+      (%~) SCP SCF = Disproved (\ x -> case x of)+      (%~) SCP SCG = Disproved (\ x -> case x of)+      (%~) SCP SCH = Disproved (\ x -> case x of)+      (%~) SCP SCI = Disproved (\ x -> case x of)+      (%~) SCP SCJ = Disproved (\ x -> case x of)+      (%~) SCP SCK = Disproved (\ x -> case x of)+      (%~) SCP SCL = Disproved (\ x -> case x of)+      (%~) SCP SCM = Disproved (\ x -> case x of)+      (%~) SCP SCN = Disproved (\ x -> case x of)+      (%~) SCP SCO = Disproved (\ x -> case x of)+      (%~) SCP SCP = Proved Refl+      (%~) SCP SCQ = Disproved (\ x -> case x of)+      (%~) SCP SCR = Disproved (\ x -> case x of)+      (%~) SCP SCS = Disproved (\ x -> case x of)+      (%~) SCP SCT = Disproved (\ x -> case x of)+      (%~) SCP SCU = Disproved (\ x -> case x of)+      (%~) SCP SCV = Disproved (\ x -> case x of)+      (%~) SCP SCW = Disproved (\ x -> case x of)+      (%~) SCP SCX = Disproved (\ x -> case x of)+      (%~) SCP SCY = Disproved (\ x -> case x of)+      (%~) SCP SCZ = Disproved (\ x -> case x of)+      (%~) SCQ SCA = Disproved (\ x -> case x of)+      (%~) SCQ SCB = Disproved (\ x -> case x of)+      (%~) SCQ SCC = Disproved (\ x -> case x of)+      (%~) SCQ SCD = Disproved (\ x -> case x of)+      (%~) SCQ SCE = Disproved (\ x -> case x of)+      (%~) SCQ SCF = Disproved (\ x -> case x of)+      (%~) SCQ SCG = Disproved (\ x -> case x of)+      (%~) SCQ SCH = Disproved (\ x -> case x of)+      (%~) SCQ SCI = Disproved (\ x -> case x of)+      (%~) SCQ SCJ = Disproved (\ x -> case x of)+      (%~) SCQ SCK = Disproved (\ x -> case x of)+      (%~) SCQ SCL = Disproved (\ x -> case x of)+      (%~) SCQ SCM = Disproved (\ x -> case x of)+      (%~) SCQ SCN = Disproved (\ x -> case x of)+      (%~) SCQ SCO = Disproved (\ x -> case x of)+      (%~) SCQ SCP = Disproved (\ x -> case x of)+      (%~) SCQ SCQ = Proved Refl+      (%~) SCQ SCR = Disproved (\ x -> case x of)+      (%~) SCQ SCS = Disproved (\ x -> case x of)+      (%~) SCQ SCT = Disproved (\ x -> case x of)+      (%~) SCQ SCU = Disproved (\ x -> case x of)+      (%~) SCQ SCV = Disproved (\ x -> case x of)+      (%~) SCQ SCW = Disproved (\ x -> case x of)+      (%~) SCQ SCX = Disproved (\ x -> case x of)+      (%~) SCQ SCY = Disproved (\ x -> case x of)+      (%~) SCQ SCZ = Disproved (\ x -> case x of)+      (%~) SCR SCA = Disproved (\ x -> case x of)+      (%~) SCR SCB = Disproved (\ x -> case x of)+      (%~) SCR SCC = Disproved (\ x -> case x of)+      (%~) SCR SCD = Disproved (\ x -> case x of)+      (%~) SCR SCE = Disproved (\ x -> case x of)+      (%~) SCR SCF = Disproved (\ x -> case x of)+      (%~) SCR SCG = Disproved (\ x -> case x of)+      (%~) SCR SCH = Disproved (\ x -> case x of)+      (%~) SCR SCI = Disproved (\ x -> case x of)+      (%~) SCR SCJ = Disproved (\ x -> case x of)+      (%~) SCR SCK = Disproved (\ x -> case x of)+      (%~) SCR SCL = Disproved (\ x -> case x of)+      (%~) SCR SCM = Disproved (\ x -> case x of)+      (%~) SCR SCN = Disproved (\ x -> case x of)+      (%~) SCR SCO = Disproved (\ x -> case x of)+      (%~) SCR SCP = Disproved (\ x -> case x of)+      (%~) SCR SCQ = Disproved (\ x -> case x of)+      (%~) SCR SCR = Proved Refl+      (%~) SCR SCS = Disproved (\ x -> case x of)+      (%~) SCR SCT = Disproved (\ x -> case x of)+      (%~) SCR SCU = Disproved (\ x -> case x of)+      (%~) SCR SCV = Disproved (\ x -> case x of)+      (%~) SCR SCW = Disproved (\ x -> case x of)+      (%~) SCR SCX = Disproved (\ x -> case x of)+      (%~) SCR SCY = Disproved (\ x -> case x of)+      (%~) SCR SCZ = Disproved (\ x -> case x of)+      (%~) SCS SCA = Disproved (\ x -> case x of)+      (%~) SCS SCB = Disproved (\ x -> case x of)+      (%~) SCS SCC = Disproved (\ x -> case x of)+      (%~) SCS SCD = Disproved (\ x -> case x of)+      (%~) SCS SCE = Disproved (\ x -> case x of)+      (%~) SCS SCF = Disproved (\ x -> case x of)+      (%~) SCS SCG = Disproved (\ x -> case x of)+      (%~) SCS SCH = Disproved (\ x -> case x of)+      (%~) SCS SCI = Disproved (\ x -> case x of)+      (%~) SCS SCJ = Disproved (\ x -> case x of)+      (%~) SCS SCK = Disproved (\ x -> case x of)+      (%~) SCS SCL = Disproved (\ x -> case x of)+      (%~) SCS SCM = Disproved (\ x -> case x of)+      (%~) SCS SCN = Disproved (\ x -> case x of)+      (%~) SCS SCO = Disproved (\ x -> case x of)+      (%~) SCS SCP = Disproved (\ x -> case x of)+      (%~) SCS SCQ = Disproved (\ x -> case x of)+      (%~) SCS SCR = Disproved (\ x -> case x of)+      (%~) SCS SCS = Proved Refl+      (%~) SCS SCT = Disproved (\ x -> case x of)+      (%~) SCS SCU = Disproved (\ x -> case x of)+      (%~) SCS SCV = Disproved (\ x -> case x of)+      (%~) SCS SCW = Disproved (\ x -> case x of)+      (%~) SCS SCX = Disproved (\ x -> case x of)+      (%~) SCS SCY = Disproved (\ x -> case x of)+      (%~) SCS SCZ = Disproved (\ x -> case x of)+      (%~) SCT SCA = Disproved (\ x -> case x of)+      (%~) SCT SCB = Disproved (\ x -> case x of)+      (%~) SCT SCC = Disproved (\ x -> case x of)+      (%~) SCT SCD = Disproved (\ x -> case x of)+      (%~) SCT SCE = Disproved (\ x -> case x of)+      (%~) SCT SCF = Disproved (\ x -> case x of)+      (%~) SCT SCG = Disproved (\ x -> case x of)+      (%~) SCT SCH = Disproved (\ x -> case x of)+      (%~) SCT SCI = Disproved (\ x -> case x of)+      (%~) SCT SCJ = Disproved (\ x -> case x of)+      (%~) SCT SCK = Disproved (\ x -> case x of)+      (%~) SCT SCL = Disproved (\ x -> case x of)+      (%~) SCT SCM = Disproved (\ x -> case x of)+      (%~) SCT SCN = Disproved (\ x -> case x of)+      (%~) SCT SCO = Disproved (\ x -> case x of)+      (%~) SCT SCP = Disproved (\ x -> case x of)+      (%~) SCT SCQ = Disproved (\ x -> case x of)+      (%~) SCT SCR = Disproved (\ x -> case x of)+      (%~) SCT SCS = Disproved (\ x -> case x of)+      (%~) SCT SCT = Proved Refl+      (%~) SCT SCU = Disproved (\ x -> case x of)+      (%~) SCT SCV = Disproved (\ x -> case x of)+      (%~) SCT SCW = Disproved (\ x -> case x of)+      (%~) SCT SCX = Disproved (\ x -> case x of)+      (%~) SCT SCY = Disproved (\ x -> case x of)+      (%~) SCT SCZ = Disproved (\ x -> case x of)+      (%~) SCU SCA = Disproved (\ x -> case x of)+      (%~) SCU SCB = Disproved (\ x -> case x of)+      (%~) SCU SCC = Disproved (\ x -> case x of)+      (%~) SCU SCD = Disproved (\ x -> case x of)+      (%~) SCU SCE = Disproved (\ x -> case x of)+      (%~) SCU SCF = Disproved (\ x -> case x of)+      (%~) SCU SCG = Disproved (\ x -> case x of)+      (%~) SCU SCH = Disproved (\ x -> case x of)+      (%~) SCU SCI = Disproved (\ x -> case x of)+      (%~) SCU SCJ = Disproved (\ x -> case x of)+      (%~) SCU SCK = Disproved (\ x -> case x of)+      (%~) SCU SCL = Disproved (\ x -> case x of)+      (%~) SCU SCM = Disproved (\ x -> case x of)+      (%~) SCU SCN = Disproved (\ x -> case x of)+      (%~) SCU SCO = Disproved (\ x -> case x of)+      (%~) SCU SCP = Disproved (\ x -> case x of)+      (%~) SCU SCQ = Disproved (\ x -> case x of)+      (%~) SCU SCR = Disproved (\ x -> case x of)+      (%~) SCU SCS = Disproved (\ x -> case x of)+      (%~) SCU SCT = Disproved (\ x -> case x of)+      (%~) SCU SCU = Proved Refl+      (%~) SCU SCV = Disproved (\ x -> case x of)+      (%~) SCU SCW = Disproved (\ x -> case x of)+      (%~) SCU SCX = Disproved (\ x -> case x of)+      (%~) SCU SCY = Disproved (\ x -> case x of)+      (%~) SCU SCZ = Disproved (\ x -> case x of)+      (%~) SCV SCA = Disproved (\ x -> case x of)+      (%~) SCV SCB = Disproved (\ x -> case x of)+      (%~) SCV SCC = Disproved (\ x -> case x of)+      (%~) SCV SCD = Disproved (\ x -> case x of)+      (%~) SCV SCE = Disproved (\ x -> case x of)+      (%~) SCV SCF = Disproved (\ x -> case x of)+      (%~) SCV SCG = Disproved (\ x -> case x of)+      (%~) SCV SCH = Disproved (\ x -> case x of)+      (%~) SCV SCI = Disproved (\ x -> case x of)+      (%~) SCV SCJ = Disproved (\ x -> case x of)+      (%~) SCV SCK = Disproved (\ x -> case x of)+      (%~) SCV SCL = Disproved (\ x -> case x of)+      (%~) SCV SCM = Disproved (\ x -> case x of)+      (%~) SCV SCN = Disproved (\ x -> case x of)+      (%~) SCV SCO = Disproved (\ x -> case x of)+      (%~) SCV SCP = Disproved (\ x -> case x of)+      (%~) SCV SCQ = Disproved (\ x -> case x of)+      (%~) SCV SCR = Disproved (\ x -> case x of)+      (%~) SCV SCS = Disproved (\ x -> case x of)+      (%~) SCV SCT = Disproved (\ x -> case x of)+      (%~) SCV SCU = Disproved (\ x -> case x of)+      (%~) SCV SCV = Proved Refl+      (%~) SCV SCW = Disproved (\ x -> case x of)+      (%~) SCV SCX = Disproved (\ x -> case x of)+      (%~) SCV SCY = Disproved (\ x -> case x of)+      (%~) SCV SCZ = Disproved (\ x -> case x of)+      (%~) SCW SCA = Disproved (\ x -> case x of)+      (%~) SCW SCB = Disproved (\ x -> case x of)+      (%~) SCW SCC = Disproved (\ x -> case x of)+      (%~) SCW SCD = Disproved (\ x -> case x of)+      (%~) SCW SCE = Disproved (\ x -> case x of)+      (%~) SCW SCF = Disproved (\ x -> case x of)+      (%~) SCW SCG = Disproved (\ x -> case x of)+      (%~) SCW SCH = Disproved (\ x -> case x of)+      (%~) SCW SCI = Disproved (\ x -> case x of)+      (%~) SCW SCJ = Disproved (\ x -> case x of)+      (%~) SCW SCK = Disproved (\ x -> case x of)+      (%~) SCW SCL = Disproved (\ x -> case x of)+      (%~) SCW SCM = Disproved (\ x -> case x of)+      (%~) SCW SCN = Disproved (\ x -> case x of)+      (%~) SCW SCO = Disproved (\ x -> case x of)+      (%~) SCW SCP = Disproved (\ x -> case x of)+      (%~) SCW SCQ = Disproved (\ x -> case x of)+      (%~) SCW SCR = Disproved (\ x -> case x of)+      (%~) SCW SCS = Disproved (\ x -> case x of)+      (%~) SCW SCT = Disproved (\ x -> case x of)+      (%~) SCW SCU = Disproved (\ x -> case x of)+      (%~) SCW SCV = Disproved (\ x -> case x of)+      (%~) SCW SCW = Proved Refl+      (%~) SCW SCX = Disproved (\ x -> case x of)+      (%~) SCW SCY = Disproved (\ x -> case x of)+      (%~) SCW SCZ = Disproved (\ x -> case x of)+      (%~) SCX SCA = Disproved (\ x -> case x of)+      (%~) SCX SCB = Disproved (\ x -> case x of)+      (%~) SCX SCC = Disproved (\ x -> case x of)+      (%~) SCX SCD = Disproved (\ x -> case x of)+      (%~) SCX SCE = Disproved (\ x -> case x of)+      (%~) SCX SCF = Disproved (\ x -> case x of)+      (%~) SCX SCG = Disproved (\ x -> case x of)+      (%~) SCX SCH = Disproved (\ x -> case x of)+      (%~) SCX SCI = Disproved (\ x -> case x of)+      (%~) SCX SCJ = Disproved (\ x -> case x of)+      (%~) SCX SCK = Disproved (\ x -> case x of)+      (%~) SCX SCL = Disproved (\ x -> case x of)+      (%~) SCX SCM = Disproved (\ x -> case x of)+      (%~) SCX SCN = Disproved (\ x -> case x of)+      (%~) SCX SCO = Disproved (\ x -> case x of)+      (%~) SCX SCP = Disproved (\ x -> case x of)+      (%~) SCX SCQ = Disproved (\ x -> case x of)+      (%~) SCX SCR = Disproved (\ x -> case x of)+      (%~) SCX SCS = Disproved (\ x -> case x of)+      (%~) SCX SCT = Disproved (\ x -> case x of)+      (%~) SCX SCU = Disproved (\ x -> case x of)+      (%~) SCX SCV = Disproved (\ x -> case x of)+      (%~) SCX SCW = Disproved (\ x -> case x of)+      (%~) SCX SCX = Proved Refl+      (%~) SCX SCY = Disproved (\ x -> case x of)+      (%~) SCX SCZ = Disproved (\ x -> case x of)+      (%~) SCY SCA = Disproved (\ x -> case x of)+      (%~) SCY SCB = Disproved (\ x -> case x of)+      (%~) SCY SCC = Disproved (\ x -> case x of)+      (%~) SCY SCD = Disproved (\ x -> case x of)+      (%~) SCY SCE = Disproved (\ x -> case x of)+      (%~) SCY SCF = Disproved (\ x -> case x of)+      (%~) SCY SCG = Disproved (\ x -> case x of)+      (%~) SCY SCH = Disproved (\ x -> case x of)+      (%~) SCY SCI = Disproved (\ x -> case x of)+      (%~) SCY SCJ = Disproved (\ x -> case x of)+      (%~) SCY SCK = Disproved (\ x -> case x of)+      (%~) SCY SCL = Disproved (\ x -> case x of)+      (%~) SCY SCM = Disproved (\ x -> case x of)+      (%~) SCY SCN = Disproved (\ x -> case x of)+      (%~) SCY SCO = Disproved (\ x -> case x of)+      (%~) SCY SCP = Disproved (\ x -> case x of)+      (%~) SCY SCQ = Disproved (\ x -> case x of)+      (%~) SCY SCR = Disproved (\ x -> case x of)+      (%~) SCY SCS = Disproved (\ x -> case x of)+      (%~) SCY SCT = Disproved (\ x -> case x of)+      (%~) SCY SCU = Disproved (\ x -> case x of)+      (%~) SCY SCV = Disproved (\ x -> case x of)+      (%~) SCY SCW = Disproved (\ x -> case x of)+      (%~) SCY SCX = Disproved (\ x -> case x of)+      (%~) SCY SCY = Proved Refl+      (%~) SCY SCZ = Disproved (\ x -> case x of)+      (%~) SCZ SCA = Disproved (\ x -> case x of)+      (%~) SCZ SCB = Disproved (\ x -> case x of)+      (%~) SCZ SCC = Disproved (\ x -> case x of)+      (%~) SCZ SCD = Disproved (\ x -> case x of)+      (%~) SCZ SCE = Disproved (\ x -> case x of)+      (%~) SCZ SCF = Disproved (\ x -> case x of)+      (%~) SCZ SCG = Disproved (\ x -> case x of)+      (%~) SCZ SCH = Disproved (\ x -> case x of)+      (%~) SCZ SCI = Disproved (\ x -> case x of)+      (%~) SCZ SCJ = Disproved (\ x -> case x of)+      (%~) SCZ SCK = Disproved (\ x -> case x of)+      (%~) SCZ SCL = Disproved (\ x -> case x of)+      (%~) SCZ SCM = Disproved (\ x -> case x of)+      (%~) SCZ SCN = Disproved (\ x -> case x of)+      (%~) SCZ SCO = Disproved (\ x -> case x of)+      (%~) SCZ SCP = Disproved (\ x -> case x of)+      (%~) SCZ SCQ = Disproved (\ x -> case x of)+      (%~) SCZ SCR = Disproved (\ x -> case x of)+      (%~) SCZ SCS = Disproved (\ x -> case x of)+      (%~) SCZ SCT = Disproved (\ x -> case x of)+      (%~) SCZ SCU = Disproved (\ x -> case x of)+      (%~) SCZ SCV = Disproved (\ x -> case x of)+      (%~) SCZ SCW = Disproved (\ x -> case x of)+      (%~) SCZ SCX = Disproved (\ x -> case x of)+      (%~) SCZ SCY = Disproved (\ x -> case x of)+      (%~) SCZ SCZ = Proved Refl+    instance Data.Type.Equality.TestEquality (SAChar :: AChar+                                                        -> Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance Data.Type.Coercion.TestCoercion (SAChar :: AChar+                                                        -> Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance (Data.Singletons.ShowSing.ShowSing U,+              Data.Singletons.ShowSing.ShowSing Nat) =>+             Show (SU (z :: U)) where+      showsPrec _ SBOOL = showString "SBOOL"+      showsPrec _ SSTRING = showString "SSTRING"+      showsPrec _ SNAT = showString "SNAT"+      showsPrec+        p_0123456789876543210+        (SVEC (arg_0123456789876543210 :: Sing argTy_0123456789876543210)+              (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SVEC "))+               (((.) ((showsPrec 11) arg_0123456789876543210))+                  (((.) GHC.Show.showSpace)+                     ((showsPrec 11) arg_0123456789876543210)))) ::+            (Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210) =>+            ShowS+    instance Show (SAChar (z :: AChar)) where+      showsPrec _ SCA = showString "SCA"+      showsPrec _ SCB = showString "SCB"+      showsPrec _ SCC = showString "SCC"+      showsPrec _ SCD = showString "SCD"+      showsPrec _ SCE = showString "SCE"+      showsPrec _ SCF = showString "SCF"+      showsPrec _ SCG = showString "SCG"+      showsPrec _ SCH = showString "SCH"+      showsPrec _ SCI = showString "SCI"+      showsPrec _ SCJ = showString "SCJ"+      showsPrec _ SCK = showString "SCK"+      showsPrec _ SCL = showString "SCL"+      showsPrec _ SCM = showString "SCM"+      showsPrec _ SCN = showString "SCN"+      showsPrec _ SCO = showString "SCO"+      showsPrec _ SCP = showString "SCP"+      showsPrec _ SCQ = showString "SCQ"+      showsPrec _ SCR = showString "SCR"+      showsPrec _ SCS = showString "SCS"+      showsPrec _ SCT = showString "SCT"+      showsPrec _ SCU = showString "SCU"+      showsPrec _ SCV = showString "SCV"+      showsPrec _ SCW = showString "SCW"+      showsPrec _ SCX = showString "SCX"+      showsPrec _ SCY = showString "SCY"+      showsPrec _ SCZ = showString "SCZ"+    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 (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 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 (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 SingI n => SingI (Sch (n :: [Attribute])) where+      sing = SSch sing+    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
− tests/compile-and-dump/GradingClient/Main.ghc86.template 
@@ -1,123 +0,0 @@-GradingClient/Main.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| lastName, firstName, yearName, gradeName, majorName :: [AChar]-          lastName = [CL, CA, CS, CT]-          firstName = [CF, CI, CR, CS, CT]-          yearName = [CY, CE, CA, CR]-          gradeName = [CG, CR, CA, CD, CE]-          majorName = [CM, CA, CJ, CO, CR]-          gradingSchema :: Schema-          gradingSchema-            = Sch-                [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT,-                 Attr gradeName NAT, Attr majorName BOOL]-          names :: Schema-          names = Sch [Attr firstName STRING, Attr lastName STRING] |]-  ======>-    lastName :: [AChar]-    firstName :: [AChar]-    yearName :: [AChar]-    gradeName :: [AChar]-    majorName :: [AChar]-    lastName = [CL, CA, CS, CT]-    firstName = [CF, CI, CR, CS, CT]-    yearName = [CY, CE, CA, CR]-    gradeName = [CG, CR, CA, CD, CE]-    majorName = [CM, CA, CJ, CO, CR]-    gradingSchema :: Schema-    gradingSchema-      = Sch-          [(Attr lastName) STRING, (Attr firstName) STRING,-           (Attr yearName) NAT, (Attr gradeName) NAT, (Attr majorName) BOOL]-    names :: Schema-    names = Sch [(Attr firstName) STRING, (Attr lastName) STRING]-    type MajorNameSym0 = MajorName-    type GradeNameSym0 = GradeName-    type YearNameSym0 = YearName-    type FirstNameSym0 = FirstName-    type LastNameSym0 = LastName-    type GradingSchemaSym0 = GradingSchema-    type NamesSym0 = Names-    type family MajorName :: [AChar] where-      MajorName = Apply (Apply (:@#@$) CMSym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CJSym0) (Apply (Apply (:@#@$) COSym0) (Apply (Apply (:@#@$) CRSym0) '[]))))-    type family GradeName :: [AChar] where-      GradeName = Apply (Apply (:@#@$) CGSym0) (Apply (Apply (:@#@$) CRSym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CDSym0) (Apply (Apply (:@#@$) CESym0) '[]))))-    type family YearName :: [AChar] where-      YearName = Apply (Apply (:@#@$) CYSym0) (Apply (Apply (:@#@$) CESym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CRSym0) '[])))-    type family FirstName :: [AChar] where-      FirstName = Apply (Apply (:@#@$) CFSym0) (Apply (Apply (:@#@$) CISym0) (Apply (Apply (:@#@$) CRSym0) (Apply (Apply (:@#@$) CSSym0) (Apply (Apply (:@#@$) CTSym0) '[]))))-    type family LastName :: [AChar] where-      LastName = Apply (Apply (:@#@$) CLSym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CSSym0) (Apply (Apply (:@#@$) CTSym0) '[])))-    type family GradingSchema :: Schema where-      GradingSchema = Apply SchSym0 (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 YearNameSym0) NATSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 GradeNameSym0) NATSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 MajorNameSym0) BOOLSym0)) '[])))))-    type family Names :: Schema where-      Names = Apply SchSym0 (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) '[]))-    sMajorName :: Sing (MajorNameSym0 :: [AChar])-    sGradeName :: Sing (GradeNameSym0 :: [AChar])-    sYearName :: Sing (YearNameSym0 :: [AChar])-    sFirstName :: Sing (FirstNameSym0 :: [AChar])-    sLastName :: Sing (LastNameSym0 :: [AChar])-    sGradingSchema :: Sing (GradingSchemaSym0 :: Schema)-    sNames :: Sing (NamesSym0 :: Schema)-    sMajorName-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCM))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCJ))-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCO))-                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR)) SNil))))-    sGradeName-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCG))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR))-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCD))-                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCE)) SNil))))-    sYearName-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCY))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCE))-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR)) SNil)))-    sFirstName-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCF))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCI))-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR))-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCS))-                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCT)) SNil))))-    sLastName-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCL))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))-             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCS))-                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCT)) SNil)))-    sGradingSchema-      = (applySing ((singFun1 @SchSym0) SSch))-          ((applySing-              ((applySing ((singFun2 @(:@#@$)) SCons))-                 ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sLastName))-                    SSTRING)))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sFirstName))-                       SSTRING)))-                ((applySing-                    ((applySing ((singFun2 @(:@#@$)) SCons))-                       ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sYearName))-                          SNAT)))-                   ((applySing-                       ((applySing ((singFun2 @(:@#@$)) SCons))-                          ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sGradeName))-                             SNAT)))-                      ((applySing-                          ((applySing ((singFun2 @(:@#@$)) SCons))-                             ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sMajorName))-                                SBOOL)))-                         SNil)))))-    sNames-      = (applySing ((singFun1 @SchSym0) SSch))-          ((applySing-              ((applySing ((singFun2 @(:@#@$)) SCons))-                 ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sFirstName))-                    SSTRING)))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sLastName))-                       SSTRING)))-                SNil))
+ tests/compile-and-dump/GradingClient/Main.ghc88.template view
@@ -0,0 +1,123 @@+GradingClient/Main.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| lastName, firstName, yearName, gradeName, majorName :: [AChar]+          lastName = [CL, CA, CS, CT]+          firstName = [CF, CI, CR, CS, CT]+          yearName = [CY, CE, CA, CR]+          gradeName = [CG, CR, CA, CD, CE]+          majorName = [CM, CA, CJ, CO, CR]+          gradingSchema :: Schema+          gradingSchema+            = Sch+                [Attr lastName STRING, Attr firstName STRING, Attr yearName NAT,+                 Attr gradeName NAT, Attr majorName BOOL]+          names :: Schema+          names = Sch [Attr firstName STRING, Attr lastName STRING] |]+  ======>+    lastName :: [AChar]+    firstName :: [AChar]+    yearName :: [AChar]+    gradeName :: [AChar]+    majorName :: [AChar]+    lastName = [CL, CA, CS, CT]+    firstName = [CF, CI, CR, CS, CT]+    yearName = [CY, CE, CA, CR]+    gradeName = [CG, CR, CA, CD, CE]+    majorName = [CM, CA, CJ, CO, CR]+    gradingSchema :: Schema+    gradingSchema+      = Sch+          [(Attr lastName) STRING, (Attr firstName) STRING,+           (Attr yearName) NAT, (Attr gradeName) NAT, (Attr majorName) BOOL]+    names :: Schema+    names = Sch [(Attr firstName) STRING, (Attr lastName) STRING]+    type NamesSym0 = Names+    type GradingSchemaSym0 = GradingSchema+    type MajorNameSym0 = MajorName+    type GradeNameSym0 = GradeName+    type YearNameSym0 = YearName+    type FirstNameSym0 = FirstName+    type LastNameSym0 = LastName+    type family Names :: Schema where+      Names = Apply SchSym0 (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) '[]))+    type family GradingSchema :: Schema where+      GradingSchema = Apply SchSym0 (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 LastNameSym0) STRINGSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 FirstNameSym0) STRINGSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 YearNameSym0) NATSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 GradeNameSym0) NATSym0)) (Apply (Apply (:@#@$) (Apply (Apply AttrSym0 MajorNameSym0) BOOLSym0)) '[])))))+    type family MajorName :: [AChar] where+      MajorName = Apply (Apply (:@#@$) CMSym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CJSym0) (Apply (Apply (:@#@$) COSym0) (Apply (Apply (:@#@$) CRSym0) '[]))))+    type family GradeName :: [AChar] where+      GradeName = Apply (Apply (:@#@$) CGSym0) (Apply (Apply (:@#@$) CRSym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CDSym0) (Apply (Apply (:@#@$) CESym0) '[]))))+    type family YearName :: [AChar] where+      YearName = Apply (Apply (:@#@$) CYSym0) (Apply (Apply (:@#@$) CESym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CRSym0) '[])))+    type family FirstName :: [AChar] where+      FirstName = Apply (Apply (:@#@$) CFSym0) (Apply (Apply (:@#@$) CISym0) (Apply (Apply (:@#@$) CRSym0) (Apply (Apply (:@#@$) CSSym0) (Apply (Apply (:@#@$) CTSym0) '[]))))+    type family LastName :: [AChar] where+      LastName = Apply (Apply (:@#@$) CLSym0) (Apply (Apply (:@#@$) CASym0) (Apply (Apply (:@#@$) CSSym0) (Apply (Apply (:@#@$) CTSym0) '[])))+    sNames :: Sing (NamesSym0 :: Schema)+    sGradingSchema :: Sing (GradingSchemaSym0 :: Schema)+    sMajorName :: Sing (MajorNameSym0 :: [AChar])+    sGradeName :: Sing (GradeNameSym0 :: [AChar])+    sYearName :: Sing (YearNameSym0 :: [AChar])+    sFirstName :: Sing (FirstNameSym0 :: [AChar])+    sLastName :: Sing (LastNameSym0 :: [AChar])+    sNames+      = (applySing ((singFun1 @SchSym0) SSch))+          ((applySing+              ((applySing ((singFun2 @(:@#@$)) SCons))+                 ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sFirstName))+                    SSTRING)))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sLastName))+                       SSTRING)))+                SNil))+    sGradingSchema+      = (applySing ((singFun1 @SchSym0) SSch))+          ((applySing+              ((applySing ((singFun2 @(:@#@$)) SCons))+                 ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sLastName))+                    SSTRING)))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sFirstName))+                       SSTRING)))+                ((applySing+                    ((applySing ((singFun2 @(:@#@$)) SCons))+                       ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sYearName))+                          SNAT)))+                   ((applySing+                       ((applySing ((singFun2 @(:@#@$)) SCons))+                          ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sGradeName))+                             SNAT)))+                      ((applySing+                          ((applySing ((singFun2 @(:@#@$)) SCons))+                             ((applySing ((applySing ((singFun2 @AttrSym0) SAttr)) sMajorName))+                                SBOOL)))+                         SNil)))))+    sMajorName+      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCM))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))+             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCJ))+                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCO))+                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR)) SNil))))+    sGradeName+      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCG))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR))+             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))+                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCD))+                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCE)) SNil))))+    sYearName+      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCY))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCE))+             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))+                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR)) SNil)))+    sFirstName+      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCF))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCI))+             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCR))+                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCS))+                   ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCT)) SNil))))+    sLastName+      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCL))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCA))+             ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCS))+                ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SCT)) SNil)))
− tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc86.template 
@@ -1,212 +0,0 @@-InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations-    singletons [d| data Nat = Zero | Succ Nat |]-  ======>-    data Nat = Zero | Succ Nat-    type ZeroSym0 = Zero-    type SuccSym1 (t0123456789876543210 :: Nat) =-        Succ t0123456789876543210-    instance SuppressUnusedWarnings SuccSym0 where-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())-    data SuccSym0 :: (~>) Nat Nat-      where-        SuccSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>-                                 SuccSym0 t0123456789876543210-    type instance Apply SuccSym0 t0123456789876543210 = Succ t0123456789876543210-    data instance Sing :: Nat -> Type-      where-        SZero :: Sing Zero-        SSucc :: forall (n :: Nat). (Sing (n :: Nat)) -> Sing (Succ n)-    type SNat = (Sing :: Nat -> Type)-    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 SingI Zero where-      sing = SZero-    instance SingI n => SingI (Succ (n :: Nat)) where-      sing = SSucc sing-    instance SingI (SuccSym0 :: (~>) Nat Nat) where-      sing = (singFun1 @SuccSym0) SSucc-    instance SingI (TyCon1 Succ :: (~>) Nat Nat) where-      sing = (singFun1 @(TyCon1 Succ)) SSucc-InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| leq :: Nat -> Nat -> Bool-          leq Zero _ = True-          leq (Succ _) Zero = False-          leq (Succ a) (Succ b) = leq a b-          insert :: Nat -> [Nat] -> [Nat]-          insert n [] = [n]-          insert n (h : t)-            = if leq n h then (n : h : t) else h : (insert n t)-          insertionSort :: [Nat] -> [Nat]-          insertionSort [] = []-          insertionSort (h : t) = insert h (insertionSort t) |]-  ======>-    leq :: Nat -> Nat -> Bool-    leq Zero _ = True-    leq (Succ _) Zero = False-    leq (Succ a) (Succ b) = (leq a) b-    insert :: Nat -> [Nat] -> [Nat]-    insert n [] = [n]-    insert n (h : t)-      = if (leq n) h then (n : (h : t)) else (h : (insert n) t)-    insertionSort :: [Nat] -> [Nat]-    insertionSort [] = []-    insertionSort (h : t) = (insert h) (insertionSort t)-    type Let0123456789876543210Scrutinee_0123456789876543210Sym3 n0123456789876543210 h0123456789876543210 t0123456789876543210 =-        Let0123456789876543210Scrutinee_0123456789876543210 n0123456789876543210 h0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym2 h0123456789876543210 n0123456789876543210) where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210 t0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference :: forall n0123456789876543210-                                                                                       h0123456789876543210-                                                                                       t0123456789876543210-                                                                                       arg. SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n0123456789876543210 h0123456789876543210 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210 t0123456789876543210-    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 h0123456789876543210 n0123456789876543210) t0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 h0123456789876543210 n0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210) where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210 h0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: forall n0123456789876543210-                                                                                       h0123456789876543210-                                                                                       arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall n0123456789876543210-                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 n h t where-      Let0123456789876543210Scrutinee_0123456789876543210 n h t = Apply (Apply LeqSym0 n) h-    type family Case_0123456789876543210 n h t t where-      Case_0123456789876543210 n h t  'True = Apply (Apply (:@#@$) n) (Apply (Apply (:@#@$) h) t)-      Case_0123456789876543210 n h t  'False = Apply (Apply (:@#@$) h) (Apply (Apply InsertSym0 n) t)-    type LeqSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        Leq a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (LeqSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) LeqSym1KindInference) ())-    data LeqSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Bool-      where-        LeqSym1KindInference :: forall a0123456789876543210-                                       a0123456789876543210-                                       arg. SameKind (Apply (LeqSym1 a0123456789876543210) arg) (LeqSym2 a0123456789876543210 arg) =>-                                LeqSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (LeqSym1 a0123456789876543210) a0123456789876543210 = Leq a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings LeqSym0 where-      suppressUnusedWarnings = snd (((,) LeqSym0KindInference) ())-    data LeqSym0 :: (~>) Nat ((~>) Nat Bool)-      where-        LeqSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply LeqSym0 arg) (LeqSym1 arg) =>-                                LeqSym0 a0123456789876543210-    type instance Apply LeqSym0 a0123456789876543210 = LeqSym1 a0123456789876543210-    type InsertSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [Nat]) =-        Insert a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (InsertSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) InsertSym1KindInference) ())-    data InsertSym1 (a0123456789876543210 :: Nat) :: (~>) [Nat] [Nat]-      where-        InsertSym1KindInference :: forall a0123456789876543210-                                          a0123456789876543210-                                          arg. SameKind (Apply (InsertSym1 a0123456789876543210) arg) (InsertSym2 a0123456789876543210 arg) =>-                                   InsertSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (InsertSym1 a0123456789876543210) a0123456789876543210 = Insert a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings InsertSym0 where-      suppressUnusedWarnings = snd (((,) InsertSym0KindInference) ())-    data InsertSym0 :: (~>) Nat ((~>) [Nat] [Nat])-      where-        InsertSym0KindInference :: forall a0123456789876543210-                                          arg. SameKind (Apply InsertSym0 arg) (InsertSym1 arg) =>-                                   InsertSym0 a0123456789876543210-    type instance Apply InsertSym0 a0123456789876543210 = InsertSym1 a0123456789876543210-    type InsertionSortSym1 (a0123456789876543210 :: [Nat]) =-        InsertionSort a0123456789876543210-    instance SuppressUnusedWarnings InsertionSortSym0 where-      suppressUnusedWarnings-        = snd (((,) InsertionSortSym0KindInference) ())-    data InsertionSortSym0 :: (~>) [Nat] [Nat]-      where-        InsertionSortSym0KindInference :: forall a0123456789876543210-                                                 arg. SameKind (Apply InsertionSortSym0 arg) (InsertionSortSym1 arg) =>-                                          InsertionSortSym0 a0123456789876543210-    type instance Apply InsertionSortSym0 a0123456789876543210 = InsertionSort a0123456789876543210-    type family Leq (a :: Nat) (a :: Nat) :: Bool where-      Leq  'Zero _ = TrueSym0-      Leq ( 'Succ _)  'Zero = FalseSym0-      Leq ( 'Succ a) ( 'Succ b) = Apply (Apply LeqSym0 a) b-    type family Insert (a :: Nat) (a :: [Nat]) :: [Nat] where-      Insert n '[] = Apply (Apply (:@#@$) n) '[]-      Insert n ( '(:) h t) = Case_0123456789876543210 n h t (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n h t)-    type family InsertionSort (a :: [Nat]) :: [Nat] where-      InsertionSort '[] = '[]-      InsertionSort ( '(:) h t) = Apply (Apply InsertSym0 h) (Apply InsertionSortSym0 t)-    sLeq ::-      forall (t :: Nat) (t :: Nat).-      Sing t -> Sing t -> Sing (Apply (Apply LeqSym0 t) t :: Bool)-    sInsert ::-      forall (t :: Nat) (t :: [Nat]).-      Sing t -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat])-    sInsertionSort ::-      forall (t :: [Nat]).-      Sing t -> Sing (Apply InsertionSortSym0 t :: [Nat])-    sLeq SZero _ = STrue-    sLeq (SSucc _) SZero = SFalse-    sLeq (SSucc (sA :: Sing a)) (SSucc (sB :: Sing b))-      = (applySing ((applySing ((singFun2 @LeqSym0) sLeq)) sA)) sB-    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  (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)) ::-              Sing (Case_0123456789876543210 n h t (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n h t) :: [Nat])-    sInsertionSort SNil = SNil-    sInsertionSort (SCons (sH :: Sing h) (sT :: Sing t))-      = (applySing ((applySing ((singFun2 @InsertSym0) sInsert)) sH))-          ((applySing ((singFun1 @InsertionSortSym0) sInsertionSort)) sT)-    instance SingI (LeqSym0 :: (~>) Nat ((~>) Nat Bool)) where-      sing = (singFun2 @LeqSym0) sLeq-    instance SingI d =>-             SingI (LeqSym1 (d :: Nat) :: (~>) Nat Bool) where-      sing = (singFun1 @(LeqSym1 (d :: Nat))) (sLeq (sing @d))-    instance SingI (InsertSym0 :: (~>) Nat ((~>) [Nat] [Nat])) where-      sing = (singFun2 @InsertSym0) sInsert-    instance SingI d =>-             SingI (InsertSym1 (d :: Nat) :: (~>) [Nat] [Nat]) where-      sing = (singFun1 @(InsertSym1 (d :: Nat))) (sInsert (sing @d))-    instance SingI (InsertionSortSym0 :: (~>) [Nat] [Nat]) where-      sing = (singFun1 @InsertionSortSym0) sInsertionSort
+ tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc88.template view
@@ -0,0 +1,211 @@+InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations+    singletons [d| data Nat = Zero | Succ Nat |]+  ======>+    data Nat = Zero | Succ Nat+    type ZeroSym0 = Zero+    type SuccSym1 (t0123456789876543210 :: Nat) =+        Succ t0123456789876543210+    instance SuppressUnusedWarnings SuccSym0 where+      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())+    data SuccSym0 :: (~>) Nat Nat+      where+        SuccSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>+                                 SuccSym0 t0123456789876543210+    type instance Apply SuccSym0 t0123456789876543210 = Succ t0123456789876543210+    data SNat :: Nat -> Type+      where+        SZero :: SNat Zero+        SSucc :: forall (n :: Nat). (Sing (n :: Nat)) -> SNat (Succ n)+    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 SingI Zero where+      sing = SZero+    instance SingI n => SingI (Succ (n :: Nat)) where+      sing = SSucc sing+    instance SingI (SuccSym0 :: (~>) Nat Nat) where+      sing = (singFun1 @SuccSym0) SSucc+InsertionSort/InsertionSortImp.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| leq :: Nat -> Nat -> Bool+          leq Zero _ = True+          leq (Succ _) Zero = False+          leq (Succ a) (Succ b) = leq a b+          insert :: Nat -> [Nat] -> [Nat]+          insert n [] = [n]+          insert n (h : t)+            = if leq n h then (n : h : t) else h : (insert n t)+          insertionSort :: [Nat] -> [Nat]+          insertionSort [] = []+          insertionSort (h : t) = insert h (insertionSort t) |]+  ======>+    leq :: Nat -> Nat -> Bool+    leq Zero _ = True+    leq (Succ _) Zero = False+    leq (Succ a) (Succ b) = (leq a) b+    insert :: Nat -> [Nat] -> [Nat]+    insert n [] = [n]+    insert n (h : t)+      = if (leq n) h then (n : (h : t)) else (h : (insert n) t)+    insertionSort :: [Nat] -> [Nat]+    insertionSort [] = []+    insertionSort (h : t) = (insert h) (insertionSort t)+    type Let0123456789876543210Scrutinee_0123456789876543210Sym3 n0123456789876543210 h0123456789876543210 t0123456789876543210 =+        Let0123456789876543210Scrutinee_0123456789876543210 n0123456789876543210 h0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym2 h0123456789876543210 n0123456789876543210) where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210 t0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym2KindInference :: forall n0123456789876543210+                                                                                       h0123456789876543210+                                                                                       t0123456789876543210+                                                                                       arg. SameKind (Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210) arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n0123456789876543210 h0123456789876543210 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym2 n0123456789876543210 h0123456789876543210 t0123456789876543210+    type instance Apply (Let0123456789876543210Scrutinee_0123456789876543210Sym2 h0123456789876543210 n0123456789876543210) t0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 h0123456789876543210 n0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210) where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210 h0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: forall n0123456789876543210+                                                                                       h0123456789876543210+                                                                                       arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall n0123456789876543210+                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210+    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 n0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 n0123456789876543210+    type family Let0123456789876543210Scrutinee_0123456789876543210 n h t where+      Let0123456789876543210Scrutinee_0123456789876543210 n h t = Apply (Apply LeqSym0 n) h+    type family Case_0123456789876543210 n h t t where+      Case_0123456789876543210 n h t 'True = Apply (Apply (:@#@$) n) (Apply (Apply (:@#@$) h) t)+      Case_0123456789876543210 n h t 'False = Apply (Apply (:@#@$) h) (Apply (Apply InsertSym0 n) t)+    type InsertionSortSym1 (a0123456789876543210 :: [Nat]) =+        InsertionSort a0123456789876543210+    instance SuppressUnusedWarnings InsertionSortSym0 where+      suppressUnusedWarnings+        = snd (((,) InsertionSortSym0KindInference) ())+    data InsertionSortSym0 :: (~>) [Nat] [Nat]+      where+        InsertionSortSym0KindInference :: forall a0123456789876543210+                                                 arg. SameKind (Apply InsertionSortSym0 arg) (InsertionSortSym1 arg) =>+                                          InsertionSortSym0 a0123456789876543210+    type instance Apply InsertionSortSym0 a0123456789876543210 = InsertionSort a0123456789876543210+    type InsertSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [Nat]) =+        Insert a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (InsertSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) InsertSym1KindInference) ())+    data InsertSym1 (a0123456789876543210 :: Nat) :: (~>) [Nat] [Nat]+      where+        InsertSym1KindInference :: forall a0123456789876543210+                                          a0123456789876543210+                                          arg. SameKind (Apply (InsertSym1 a0123456789876543210) arg) (InsertSym2 a0123456789876543210 arg) =>+                                   InsertSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (InsertSym1 a0123456789876543210) a0123456789876543210 = Insert a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings InsertSym0 where+      suppressUnusedWarnings = snd (((,) InsertSym0KindInference) ())+    data InsertSym0 :: (~>) Nat ((~>) [Nat] [Nat])+      where+        InsertSym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply InsertSym0 arg) (InsertSym1 arg) =>+                                   InsertSym0 a0123456789876543210+    type instance Apply InsertSym0 a0123456789876543210 = InsertSym1 a0123456789876543210+    type LeqSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        Leq a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (LeqSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) LeqSym1KindInference) ())+    data LeqSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Bool+      where+        LeqSym1KindInference :: forall a0123456789876543210+                                       a0123456789876543210+                                       arg. SameKind (Apply (LeqSym1 a0123456789876543210) arg) (LeqSym2 a0123456789876543210 arg) =>+                                LeqSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (LeqSym1 a0123456789876543210) a0123456789876543210 = Leq a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings LeqSym0 where+      suppressUnusedWarnings = snd (((,) LeqSym0KindInference) ())+    data LeqSym0 :: (~>) Nat ((~>) Nat Bool)+      where+        LeqSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply LeqSym0 arg) (LeqSym1 arg) =>+                                LeqSym0 a0123456789876543210+    type instance Apply LeqSym0 a0123456789876543210 = LeqSym1 a0123456789876543210+    type family InsertionSort (a :: [Nat]) :: [Nat] where+      InsertionSort '[] = '[]+      InsertionSort ('(:) h t) = Apply (Apply InsertSym0 h) (Apply InsertionSortSym0 t)+    type family Insert (a :: Nat) (a :: [Nat]) :: [Nat] where+      Insert n '[] = Apply (Apply (:@#@$) n) '[]+      Insert n ('(:) h t) = Case_0123456789876543210 n h t (Let0123456789876543210Scrutinee_0123456789876543210Sym3 n h t)+    type family Leq (a :: Nat) (a :: Nat) :: Bool where+      Leq 'Zero _ = TrueSym0+      Leq ('Succ _) 'Zero = FalseSym0+      Leq ('Succ a) ('Succ b) = Apply (Apply LeqSym0 a) b+    sInsertionSort ::+      forall (t :: [Nat]).+      Sing t -> Sing (Apply InsertionSortSym0 t :: [Nat])+    sInsert ::+      forall (t :: Nat) (t :: [Nat]).+      Sing t -> Sing t -> Sing (Apply (Apply InsertSym0 t) t :: [Nat])+    sLeq ::+      forall (t :: Nat) (t :: Nat).+      Sing t -> Sing t -> Sing (Apply (Apply LeqSym0 t) t :: Bool)+    sInsertionSort SNil = SNil+    sInsertionSort (SCons (sH :: Sing h) (sT :: Sing t))+      = (applySing ((applySing ((singFun2 @InsertSym0) sInsert)) sH))+          ((applySing ((singFun1 @InsertionSortSym0) sInsertionSort)) sT)+    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) :: [Nat])))+            (case sScrutinee_0123456789876543210 of+               STrue+                 -> (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) sN))+                      ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) sH)) sT)+               SFalse+                 -> (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) sH))+                      ((applySing ((applySing ((singFun2 @InsertSym0) sInsert)) sN)) sT))+    sLeq SZero _ = STrue+    sLeq (SSucc _) SZero = SFalse+    sLeq (SSucc (sA :: Sing a)) (SSucc (sB :: Sing b))+      = (applySing ((applySing ((singFun2 @LeqSym0) sLeq)) sA)) sB+    instance SingI (InsertionSortSym0 :: (~>) [Nat] [Nat]) where+      sing = (singFun1 @InsertionSortSym0) sInsertionSort+    instance SingI (InsertSym0 :: (~>) Nat ((~>) [Nat] [Nat])) where+      sing = (singFun2 @InsertSym0) sInsert+    instance SingI d =>+             SingI (InsertSym1 (d :: Nat) :: (~>) [Nat] [Nat]) where+      sing = (singFun1 @(InsertSym1 (d :: Nat))) (sInsert (sing @d))+    instance SingI (LeqSym0 :: (~>) Nat ((~>) Nat Bool)) where+      sing = (singFun2 @LeqSym0) sLeq+    instance SingI d =>+             SingI (LeqSym1 (d :: Nat) :: (~>) Nat Bool) where+      sing = (singFun1 @(LeqSym1 (d :: Nat))) (sLeq (sing @d))
− tests/compile-and-dump/Promote/Constructors.ghc86.template 
@@ -1,79 +0,0 @@-Promote/Constructors.hs:(0,0)-(0,0): Splicing declarations-    promote-      [d| data Foo = Foo | Foo :+ Foo-          data Bar = Bar Bar Bar Bar Bar Foo |]-  ======>-    data Foo = Foo | Foo :+ Foo-    data Bar = Bar Bar Bar Bar Bar Foo-    type FooSym0 = Foo-    type (:+@#@$$$) (t0123456789876543210 :: Foo) (t0123456789876543210 :: Foo) =-        (:+) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:+@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::+@#@$$###)) ())-    data (:+@#@$$) (t0123456789876543210 :: Foo) :: (~>) Foo Foo-      where-        (::+@#@$$###) :: forall t0123456789876543210-                                t0123456789876543210-                                arg. SameKind (Apply ((:+@#@$$) t0123456789876543210) arg) ((:+@#@$$$) t0123456789876543210 arg) =>-                         (:+@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:+@#@$$) t0123456789876543210) t0123456789876543210 = (:+) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (:+@#@$) where-      suppressUnusedWarnings = snd (((,) (::+@#@$###)) ())-    data (:+@#@$) :: (~>) Foo ((~>) Foo Foo)-      where-        (::+@#@$###) :: forall t0123456789876543210-                               arg. SameKind (Apply (:+@#@$) arg) ((:+@#@$$) arg) =>-                        (:+@#@$) t0123456789876543210-    type instance Apply (:+@#@$) t0123456789876543210 = (:+@#@$$) t0123456789876543210-    type BarSym5 (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Foo) =-        Bar t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BarSym4KindInference) ())-    data BarSym4 (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) :: (~>) Foo Bar-      where-        BarSym4KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       t0123456789876543210-                                       t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (BarSym5 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                                BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = Bar t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BarSym3KindInference) ())-    data BarSym3 (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) :: (~>) Bar ((~>) Foo Bar)-      where-        BarSym3KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                                BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BarSym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BarSym2KindInference) ())-    data BarSym2 (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) :: (~>) Bar ((~>) Bar ((~>) Foo Bar))-      where-        BarSym2KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (BarSym2 t0123456789876543210 t0123456789876543210) arg) (BarSym3 t0123456789876543210 t0123456789876543210 arg) =>-                                BarSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (BarSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BarSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BarSym1KindInference) ())-    data BarSym1 (t0123456789876543210 :: Bar) :: (~>) Bar ((~>) Bar ((~>) Bar ((~>) Foo Bar)))-      where-        BarSym1KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (BarSym1 t0123456789876543210) arg) (BarSym2 t0123456789876543210 arg) =>-                                BarSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (BarSym1 t0123456789876543210) t0123456789876543210 = BarSym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings BarSym0 where-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())-    data BarSym0 :: (~>) Bar ((~>) Bar ((~>) Bar ((~>) Bar ((~>) Foo Bar))))-      where-        BarSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>-                                BarSym0 t0123456789876543210-    type instance Apply BarSym0 t0123456789876543210 = BarSym1 t0123456789876543210
+ tests/compile-and-dump/Promote/Constructors.ghc88.template view
@@ -0,0 +1,79 @@+Promote/Constructors.hs:(0,0)-(0,0): Splicing declarations+    promote+      [d| data Foo = Foo | Foo :+ Foo+          data Bar = Bar Bar Bar Bar Bar Foo |]+  ======>+    data Foo = Foo | Foo :+ Foo+    data Bar = Bar Bar Bar Bar Bar Foo+    type FooSym0 = Foo+    type (:+@#@$$$) (t0123456789876543210 :: Foo) (t0123456789876543210 :: Foo) =+        (:+) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:+@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::+@#@$$###)) ())+    data (:+@#@$$) (t0123456789876543210 :: Foo) :: (~>) Foo Foo+      where+        (::+@#@$$###) :: forall t0123456789876543210+                                t0123456789876543210+                                arg. SameKind (Apply ((:+@#@$$) t0123456789876543210) arg) ((:+@#@$$$) t0123456789876543210 arg) =>+                         (:+@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:+@#@$$) t0123456789876543210) t0123456789876543210 = (:+) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (:+@#@$) where+      suppressUnusedWarnings = snd (((,) (::+@#@$###)) ())+    data (:+@#@$) :: (~>) Foo ((~>) Foo Foo)+      where+        (::+@#@$###) :: forall t0123456789876543210+                               arg. SameKind (Apply (:+@#@$) arg) ((:+@#@$$) arg) =>+                        (:+@#@$) t0123456789876543210+    type instance Apply (:+@#@$) t0123456789876543210 = (:+@#@$$) t0123456789876543210+    type BarSym5 (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Foo) =+        Bar t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BarSym4KindInference) ())+    data BarSym4 (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) :: (~>) Foo Bar+      where+        BarSym4KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       t0123456789876543210+                                       t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (BarSym5 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                                BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = Bar t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BarSym3KindInference) ())+    data BarSym3 (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) :: (~>) Bar ((~>) Foo Bar)+      where+        BarSym3KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                                BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = BarSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BarSym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BarSym2KindInference) ())+    data BarSym2 (t0123456789876543210 :: Bar) (t0123456789876543210 :: Bar) :: (~>) Bar ((~>) Bar ((~>) Foo Bar))+      where+        BarSym2KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (BarSym2 t0123456789876543210 t0123456789876543210) arg) (BarSym3 t0123456789876543210 t0123456789876543210 arg) =>+                                BarSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (BarSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = BarSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BarSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BarSym1KindInference) ())+    data BarSym1 (t0123456789876543210 :: Bar) :: (~>) Bar ((~>) Bar ((~>) Bar ((~>) Foo Bar)))+      where+        BarSym1KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (BarSym1 t0123456789876543210) arg) (BarSym2 t0123456789876543210 arg) =>+                                BarSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (BarSym1 t0123456789876543210) t0123456789876543210 = BarSym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings BarSym0 where+      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())+    data BarSym0 :: (~>) Bar ((~>) Bar ((~>) Bar ((~>) Bar ((~>) Foo Bar))))+      where+        BarSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>+                                BarSym0 t0123456789876543210+    type instance Apply BarSym0 t0123456789876543210 = BarSym1 t0123456789876543210
− tests/compile-and-dump/Promote/GenDefunSymbols.ghc86.template 
@@ -1,54 +0,0 @@-Promote/GenDefunSymbols.hs:0:0:: Splicing declarations-    genDefunSymbols [''LiftMaybe, ''NatT, ''(:+)]-  ======>-    type LiftMaybeSym2 (f0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (x0123456789876543210 :: Maybe a0123456789876543210) =-        LiftMaybe f0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (LiftMaybeSym1 f0123456789876543210) where-      suppressUnusedWarnings = snd (((,) LiftMaybeSym1KindInference) ())-    data LiftMaybeSym1 (f0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) (Maybe a0123456789876543210) (Maybe b0123456789876543210)-      where-        LiftMaybeSym1KindInference :: forall f0123456789876543210-                                             x0123456789876543210-                                             arg. Data.Singletons.Internal.SameKind (Apply (LiftMaybeSym1 f0123456789876543210) arg) (LiftMaybeSym2 f0123456789876543210 arg) =>-                                      LiftMaybeSym1 f0123456789876543210 x0123456789876543210-    type instance Apply (LiftMaybeSym1 f0123456789876543210) x0123456789876543210 = LiftMaybe f0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings LiftMaybeSym0 where-      suppressUnusedWarnings = snd (((,) LiftMaybeSym0KindInference) ())-    data LiftMaybeSym0 :: forall a0123456789876543210-                                 b0123456789876543210.-                          (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) (Maybe a0123456789876543210) (Maybe b0123456789876543210))-      where-        LiftMaybeSym0KindInference :: forall f0123456789876543210-                                             arg. Data.Singletons.Internal.SameKind (Apply LiftMaybeSym0 arg) (LiftMaybeSym1 arg) =>-                                      LiftMaybeSym0 f0123456789876543210-    type instance Apply LiftMaybeSym0 f0123456789876543210 = LiftMaybeSym1 f0123456789876543210-    type ZeroSym0 =  'Zero-    type SuccSym1 (t0123456789876543210 :: NatT) =-         'Succ t0123456789876543210-    instance SuppressUnusedWarnings SuccSym0 where-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())-    data SuccSym0 :: (~>) NatT NatT-      where-        SuccSym0KindInference :: forall t0123456789876543210-                                        arg. Data.Singletons.Internal.SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>-                                 SuccSym0 t0123456789876543210-    type instance Apply SuccSym0 t0123456789876543210 =  'Succ t0123456789876543210-    type (:+@#@$$$) (a0123456789876543210 :: Nat) (b0123456789876543210 :: Nat) =-        (:+) a0123456789876543210 b0123456789876543210-    instance SuppressUnusedWarnings ((:+@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::+@#@$$###)) ())-    data (:+@#@$$) (a0123456789876543210 :: Nat) b0123456789876543210-      where-        (::+@#@$$###) :: forall a0123456789876543210-                                b0123456789876543210-                                arg. Data.Singletons.Internal.SameKind (Apply ((:+@#@$$) a0123456789876543210) arg) ((:+@#@$$$) a0123456789876543210 arg) =>-                         (:+@#@$$) a0123456789876543210 b0123456789876543210-    type instance Apply ((:+@#@$$) a0123456789876543210) b0123456789876543210 = (:+) a0123456789876543210 b0123456789876543210-    instance SuppressUnusedWarnings (:+@#@$) where-      suppressUnusedWarnings = snd (((,) (::+@#@$###)) ())-    data (:+@#@$) a0123456789876543210-      where-        (::+@#@$###) :: forall a0123456789876543210-                               arg. Data.Singletons.Internal.SameKind (Apply (:+@#@$) arg) ((:+@#@$$) arg) =>-                        (:+@#@$) a0123456789876543210-    type instance Apply (:+@#@$) a0123456789876543210 = (:+@#@$$) a0123456789876543210
+ tests/compile-and-dump/Promote/GenDefunSymbols.ghc88.template view
@@ -0,0 +1,54 @@+Promote/GenDefunSymbols.hs:0:0:: Splicing declarations+    genDefunSymbols [''LiftMaybe, ''NatT, ''(:+)]+  ======>+    type LiftMaybeSym2 (f0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (x0123456789876543210 :: Maybe a0123456789876543210) =+        LiftMaybe f0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings (LiftMaybeSym1 f0123456789876543210) where+      suppressUnusedWarnings = snd (((,) LiftMaybeSym1KindInference) ())+    data LiftMaybeSym1 (f0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) (Maybe a0123456789876543210) (Maybe b0123456789876543210)+      where+        LiftMaybeSym1KindInference :: forall f0123456789876543210+                                             x0123456789876543210+                                             arg. Data.Singletons.Internal.SameKind (Apply (LiftMaybeSym1 f0123456789876543210) arg) (LiftMaybeSym2 f0123456789876543210 arg) =>+                                      LiftMaybeSym1 f0123456789876543210 x0123456789876543210+    type instance Apply (LiftMaybeSym1 f0123456789876543210) x0123456789876543210 = LiftMaybe f0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings LiftMaybeSym0 where+      suppressUnusedWarnings = snd (((,) LiftMaybeSym0KindInference) ())+    data LiftMaybeSym0 :: forall a0123456789876543210+                                 b0123456789876543210.+                          (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) (Maybe a0123456789876543210) (Maybe b0123456789876543210))+      where+        LiftMaybeSym0KindInference :: forall f0123456789876543210+                                             arg. Data.Singletons.Internal.SameKind (Apply LiftMaybeSym0 arg) (LiftMaybeSym1 arg) =>+                                      LiftMaybeSym0 f0123456789876543210+    type instance Apply LiftMaybeSym0 f0123456789876543210 = LiftMaybeSym1 f0123456789876543210+    type ZeroSym0 = 'Zero+    type SuccSym1 (t0123456789876543210 :: NatT) =+        'Succ t0123456789876543210+    instance SuppressUnusedWarnings SuccSym0 where+      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())+    data SuccSym0 :: (~>) NatT NatT+      where+        SuccSym0KindInference :: forall t0123456789876543210+                                        arg. Data.Singletons.Internal.SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>+                                 SuccSym0 t0123456789876543210+    type instance Apply SuccSym0 t0123456789876543210 = 'Succ t0123456789876543210+    type (:+@#@$$$) (a0123456789876543210 :: Nat) (b0123456789876543210 :: Nat) =+        (:+) a0123456789876543210 b0123456789876543210+    instance SuppressUnusedWarnings ((:+@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::+@#@$$###)) ())+    data (:+@#@$$) (a0123456789876543210 :: Nat) b0123456789876543210+      where+        (::+@#@$$###) :: forall a0123456789876543210+                                b0123456789876543210+                                arg. Data.Singletons.Internal.SameKind (Apply ((:+@#@$$) a0123456789876543210) arg) ((:+@#@$$$) a0123456789876543210 arg) =>+                         (:+@#@$$) a0123456789876543210 b0123456789876543210+    type instance Apply ((:+@#@$$) a0123456789876543210) b0123456789876543210 = (:+) a0123456789876543210 b0123456789876543210+    instance SuppressUnusedWarnings (:+@#@$) where+      suppressUnusedWarnings = snd (((,) (::+@#@$###)) ())+    data (:+@#@$) a0123456789876543210+      where+        (::+@#@$###) :: forall a0123456789876543210+                               arg. Data.Singletons.Internal.SameKind (Apply (:+@#@$) arg) ((:+@#@$$) arg) =>+                        (:+@#@$) a0123456789876543210+    type instance Apply (:+@#@$) a0123456789876543210 = (:+@#@$$) a0123456789876543210
− tests/compile-and-dump/Promote/Newtypes.ghc86.template 
@@ -1,48 +0,0 @@-Promote/Newtypes.hs:(0,0)-(0,0): Splicing declarations-    promote-      [d| newtype Foo-            = Foo Nat-            deriving Eq-          newtype Bar = Bar {unBar :: Nat} |]-  ======>-    newtype Foo-      = Foo Nat-      deriving Eq-    newtype Bar = Bar {unBar :: Nat}-    type family Equals_0123456789876543210 (a :: Foo) (b :: Foo) :: Bool where-      Equals_0123456789876543210 (Foo a) (Foo b) = (==) a b-      Equals_0123456789876543210 (_ :: Foo) (_ :: Foo) = FalseSym0-    instance PEq Foo where-      type (==) a b = Equals_0123456789876543210 a b-    type UnBarSym1 (a0123456789876543210 :: Bar) =-        UnBar a0123456789876543210-    instance SuppressUnusedWarnings UnBarSym0 where-      suppressUnusedWarnings = snd (((,) UnBarSym0KindInference) ())-    data UnBarSym0 :: (~>) Bar Nat-      where-        UnBarSym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply UnBarSym0 arg) (UnBarSym1 arg) =>-                                  UnBarSym0 a0123456789876543210-    type instance Apply UnBarSym0 a0123456789876543210 = UnBar a0123456789876543210-    type family UnBar (a :: Bar) :: Nat where-      UnBar (Bar field) = field-    type FooSym1 (t0123456789876543210 :: Nat) =-        Foo t0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: (~>) Nat Foo-      where-        FooSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 t0123456789876543210-    type instance Apply FooSym0 t0123456789876543210 = Foo t0123456789876543210-    type BarSym1 (t0123456789876543210 :: Nat) =-        Bar t0123456789876543210-    instance SuppressUnusedWarnings BarSym0 where-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())-    data BarSym0 :: (~>) Nat Bar-      where-        BarSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>-                                BarSym0 t0123456789876543210-    type instance Apply BarSym0 t0123456789876543210 = Bar t0123456789876543210
+ tests/compile-and-dump/Promote/Newtypes.ghc88.template view
@@ -0,0 +1,48 @@+Promote/Newtypes.hs:(0,0)-(0,0): Splicing declarations+    promote+      [d| newtype Foo+            = Foo Nat+            deriving Eq+          newtype Bar = Bar {unBar :: Nat} |]+  ======>+    newtype Foo+      = Foo Nat+      deriving Eq+    newtype Bar = Bar {unBar :: Nat}+    type family Equals_0123456789876543210 (a :: Foo) (b :: Foo) :: Bool where+      Equals_0123456789876543210 (Foo a) (Foo b) = (==) a b+      Equals_0123456789876543210 (_ :: Foo) (_ :: Foo) = FalseSym0+    instance PEq Foo where+      type (==) a b = Equals_0123456789876543210 a b+    type UnBarSym1 (a0123456789876543210 :: Bar) =+        UnBar a0123456789876543210+    instance SuppressUnusedWarnings UnBarSym0 where+      suppressUnusedWarnings = snd (((,) UnBarSym0KindInference) ())+    data UnBarSym0 :: (~>) Bar Nat+      where+        UnBarSym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply UnBarSym0 arg) (UnBarSym1 arg) =>+                                  UnBarSym0 a0123456789876543210+    type instance Apply UnBarSym0 a0123456789876543210 = UnBar a0123456789876543210+    type family UnBar (a :: Bar) :: Nat where+      UnBar (Bar field) = field+    type FooSym1 (t0123456789876543210 :: Nat) =+        Foo t0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: (~>) Nat Foo+      where+        FooSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 t0123456789876543210+    type instance Apply FooSym0 t0123456789876543210 = Foo t0123456789876543210+    type BarSym1 (t0123456789876543210 :: Nat) =+        Bar t0123456789876543210+    instance SuppressUnusedWarnings BarSym0 where+      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())+    data BarSym0 :: (~>) Nat Bar+      where+        BarSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>+                                BarSym0 t0123456789876543210+    type instance Apply BarSym0 t0123456789876543210 = Bar t0123456789876543210
− tests/compile-and-dump/Promote/Pragmas.ghc86.template 
@@ -1,12 +0,0 @@-Promote/Pragmas.hs:(0,0)-(0,0): Splicing declarations-    promote-      [d| {-# INLINE foo #-}-          foo :: Bool-          foo = True |]-  ======>-    {-# INLINE foo #-}-    foo :: Bool-    foo = True-    type FooSym0 = Foo-    type family Foo :: Bool where-      Foo = TrueSym0
+ tests/compile-and-dump/Promote/Pragmas.ghc88.template view
@@ -0,0 +1,12 @@+Promote/Pragmas.hs:(0,0)-(0,0): Splicing declarations+    promote+      [d| {-# INLINE foo #-}+          foo :: Bool+          foo = True |]+  ======>+    {-# INLINE foo #-}+    foo :: Bool+    foo = True+    type FooSym0 = Foo+    type family Foo :: Bool where+      Foo = TrueSym0
− tests/compile-and-dump/Promote/Prelude.ghc86.template 
@@ -1,19 +0,0 @@-Promote/Prelude.hs:(0,0)-(0,0): Splicing declarations-    promoteOnly-      [d| odd :: Nat -> Bool-          odd 0 = False-          odd n = not . odd $ n - 1 |]-  ======>-    type OddSym1 (a0123456789876543210 :: Nat) =-        Odd a0123456789876543210-    instance SuppressUnusedWarnings OddSym0 where-      suppressUnusedWarnings = snd (((,) OddSym0KindInference) ())-    data OddSym0 :: (~>) Nat Bool-      where-        OddSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply OddSym0 arg) (OddSym1 arg) =>-                                OddSym0 a0123456789876543210-    type instance Apply OddSym0 a0123456789876543210 = Odd a0123456789876543210-    type family Odd (a :: Nat) :: Bool where-      Odd 0 = FalseSym0-      Odd n = Apply (Apply ($@#@$) (Apply (Apply (.@#@$) NotSym0) OddSym0)) (Apply (Apply (-@#@$) n) (FromInteger 1))
+ tests/compile-and-dump/Promote/Prelude.ghc88.template view
@@ -0,0 +1,19 @@+Promote/Prelude.hs:(0,0)-(0,0): Splicing declarations+    promoteOnly+      [d| odd :: Nat -> Bool+          odd 0 = False+          odd n = not . odd $ n - 1 |]+  ======>+    type OddSym1 (a0123456789876543210 :: Nat) =+        Odd a0123456789876543210+    instance SuppressUnusedWarnings OddSym0 where+      suppressUnusedWarnings = snd (((,) OddSym0KindInference) ())+    data OddSym0 :: (~>) Nat Bool+      where+        OddSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply OddSym0 arg) (OddSym1 arg) =>+                                OddSym0 a0123456789876543210+    type instance Apply OddSym0 a0123456789876543210 = Odd a0123456789876543210+    type family Odd (a :: Nat) :: Bool where+      Odd 0 = FalseSym0+      Odd n = Apply (Apply ($@#@$) (Apply (Apply (.@#@$) NotSym0) OddSym0)) (Apply (Apply (-@#@$) n) (FromInteger 1))
− tests/compile-and-dump/Promote/T180.ghc86.template 
@@ -1,54 +0,0 @@-Promote/T180.hs:(0,0)-(0,0): Splicing declarations-    promote-      [d| z (X1 x) = x-          z (X2 x) = x-          -          data X = X1 {y :: Symbol} | X2 {y :: Symbol} |]-  ======>-    data X = X1 {y :: Symbol} | X2 {y :: Symbol}-    z (X1 x) = x-    z (X2 x) = x-    type ZSym1 a0123456789876543210 = Z a0123456789876543210-    instance SuppressUnusedWarnings ZSym0 where-      suppressUnusedWarnings = snd (((,) ZSym0KindInference) ())-    data ZSym0 a0123456789876543210-      where-        ZSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply ZSym0 arg) (ZSym1 arg) =>-                              ZSym0 a0123456789876543210-    type instance Apply ZSym0 a0123456789876543210 = Z a0123456789876543210-    type family Z a where-      Z (X1 x) = x-      Z (X2 x) = x-    type YSym1 (a0123456789876543210 :: X) = Y a0123456789876543210-    instance SuppressUnusedWarnings YSym0 where-      suppressUnusedWarnings = snd (((,) YSym0KindInference) ())-    data YSym0 :: (~>) X Symbol-      where-        YSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply YSym0 arg) (YSym1 arg) =>-                              YSym0 a0123456789876543210-    type instance Apply YSym0 a0123456789876543210 = Y a0123456789876543210-    type family Y (a :: X) :: Symbol where-      Y (X1 field) = field-      Y (X2 field) = field-    type X1Sym1 (t0123456789876543210 :: Symbol) =-        X1 t0123456789876543210-    instance SuppressUnusedWarnings X1Sym0 where-      suppressUnusedWarnings = snd (((,) X1Sym0KindInference) ())-    data X1Sym0 :: (~>) Symbol X-      where-        X1Sym0KindInference :: forall t0123456789876543210-                                      arg. SameKind (Apply X1Sym0 arg) (X1Sym1 arg) =>-                               X1Sym0 t0123456789876543210-    type instance Apply X1Sym0 t0123456789876543210 = X1 t0123456789876543210-    type X2Sym1 (t0123456789876543210 :: Symbol) =-        X2 t0123456789876543210-    instance SuppressUnusedWarnings X2Sym0 where-      suppressUnusedWarnings = snd (((,) X2Sym0KindInference) ())-    data X2Sym0 :: (~>) Symbol X-      where-        X2Sym0KindInference :: forall t0123456789876543210-                                      arg. SameKind (Apply X2Sym0 arg) (X2Sym1 arg) =>-                               X2Sym0 t0123456789876543210-    type instance Apply X2Sym0 t0123456789876543210 = X2 t0123456789876543210
+ tests/compile-and-dump/Promote/T180.ghc88.template view
@@ -0,0 +1,54 @@+Promote/T180.hs:(0,0)-(0,0): Splicing declarations+    promote+      [d| z (X1 x) = x+          z (X2 x) = x+          +          data X = X1 {y :: Symbol} | X2 {y :: Symbol} |]+  ======>+    data X = X1 {y :: Symbol} | X2 {y :: Symbol}+    z (X1 x) = x+    z (X2 x) = x+    type ZSym1 a0123456789876543210 = Z a0123456789876543210+    instance SuppressUnusedWarnings ZSym0 where+      suppressUnusedWarnings = snd (((,) ZSym0KindInference) ())+    data ZSym0 a0123456789876543210+      where+        ZSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply ZSym0 arg) (ZSym1 arg) =>+                              ZSym0 a0123456789876543210+    type instance Apply ZSym0 a0123456789876543210 = Z a0123456789876543210+    type family Z a where+      Z (X1 x) = x+      Z (X2 x) = x+    type YSym1 (a0123456789876543210 :: X) = Y a0123456789876543210+    instance SuppressUnusedWarnings YSym0 where+      suppressUnusedWarnings = snd (((,) YSym0KindInference) ())+    data YSym0 :: (~>) X Symbol+      where+        YSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply YSym0 arg) (YSym1 arg) =>+                              YSym0 a0123456789876543210+    type instance Apply YSym0 a0123456789876543210 = Y a0123456789876543210+    type family Y (a :: X) :: Symbol where+      Y (X1 field) = field+      Y (X2 field) = field+    type X1Sym1 (t0123456789876543210 :: Symbol) =+        X1 t0123456789876543210+    instance SuppressUnusedWarnings X1Sym0 where+      suppressUnusedWarnings = snd (((,) X1Sym0KindInference) ())+    data X1Sym0 :: (~>) Symbol X+      where+        X1Sym0KindInference :: forall t0123456789876543210+                                      arg. SameKind (Apply X1Sym0 arg) (X1Sym1 arg) =>+                               X1Sym0 t0123456789876543210+    type instance Apply X1Sym0 t0123456789876543210 = X1 t0123456789876543210+    type X2Sym1 (t0123456789876543210 :: Symbol) =+        X2 t0123456789876543210+    instance SuppressUnusedWarnings X2Sym0 where+      suppressUnusedWarnings = snd (((,) X2Sym0KindInference) ())+    data X2Sym0 :: (~>) Symbol X+      where+        X2Sym0KindInference :: forall t0123456789876543210+                                      arg. SameKind (Apply X2Sym0 arg) (X2Sym1 arg) =>+                               X2Sym0 t0123456789876543210+    type instance Apply X2Sym0 t0123456789876543210 = X2 t0123456789876543210
− tests/compile-and-dump/Promote/T361.ghc86.template 
@@ -1,21 +0,0 @@-Promote/T361.hs:0:0:: Splicing declarations-    genDefunSymbols [''Proxy] ======> type ProxySym0 =  'Proxy-Promote/T361.hs:(0,0)-(0,0): Splicing declarations-    promote-      [d| f :: Proxy 1 -> Proxy 2-          f Proxy = Proxy |]-  ======>-    f :: Proxy 1 -> Proxy 2-    f Proxy = Proxy-    type FSym1 (a0123456789876543210 :: Proxy 1) =-        F a0123456789876543210-    instance SuppressUnusedWarnings FSym0 where-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())-    data FSym0 :: (~>) (Proxy 1) (Proxy 2)-      where-        FSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>-                              FSym0 a0123456789876543210-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210-    type family F (a :: Proxy 1) :: Proxy 2 where-      F  'Proxy = ProxySym0
+ tests/compile-and-dump/Promote/T361.ghc88.template view
@@ -0,0 +1,21 @@+Promote/T361.hs:0:0:: Splicing declarations+    genDefunSymbols [''Proxy] ======> type ProxySym0 = 'Proxy+Promote/T361.hs:(0,0)-(0,0): Splicing declarations+    promote+      [d| f :: Proxy 1 -> Proxy 2+          f Proxy = Proxy |]+  ======>+    f :: Proxy 1 -> Proxy 2+    f Proxy = Proxy+    type FSym1 (a0123456789876543210 :: Proxy 1) =+        F a0123456789876543210+    instance SuppressUnusedWarnings FSym0 where+      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())+    data FSym0 :: (~>) (Proxy 1) (Proxy 2)+      where+        FSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>+                              FSym0 a0123456789876543210+    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210+    type family F (a :: Proxy 1) :: Proxy 2 where+      F 'Proxy = ProxySym0
− tests/compile-and-dump/Singletons/AsPattern.ghc86.template 
@@ -1,405 +0,0 @@-Singletons/AsPattern.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| maybePlus :: Maybe Nat -> Maybe Nat-          maybePlus (Just n) = Just (plus (Succ Zero) n)-          maybePlus p@Nothing = p-          bar :: Maybe Nat -> Maybe Nat-          bar x@(Just _) = x-          bar Nothing = Nothing-          baz_ :: Maybe Baz -> Maybe Baz-          baz_ p@Nothing = p-          baz_ p@(Just (Baz _ _ _)) = p-          tup :: (Nat, Nat) -> (Nat, Nat)-          tup p@(_, _) = p-          foo :: [Nat] -> [Nat]-          foo p@[] = p-          foo p@[_] = p-          foo p@(_ : _ : _) = p-          -          data Baz = Baz Nat Nat Nat |]-  ======>-    maybePlus :: Maybe Nat -> Maybe Nat-    maybePlus (Just n) = Just ((plus (Succ Zero)) n)-    maybePlus p@Nothing = p-    bar :: Maybe Nat -> Maybe Nat-    bar x@(Just _) = x-    bar Nothing = Nothing-    data Baz = Baz Nat Nat Nat-    baz_ :: Maybe Baz -> Maybe Baz-    baz_ p@Nothing = p-    baz_ p@(Just (Baz _ _ _)) = p-    tup :: (Nat, Nat) -> (Nat, Nat)-    tup p@(_, _) = p-    foo :: [Nat] -> [Nat]-    foo p@[] = p-    foo p@[_] = p-    foo p@(_ : (_ : _)) = p-    type BazSym3 (t0123456789876543210 :: Nat) (t0123456789876543210 :: Nat) (t0123456789876543210 :: Nat) =-        Baz t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BazSym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BazSym2KindInference) ())-    data BazSym2 (t0123456789876543210 :: Nat) (t0123456789876543210 :: Nat) :: (~>) Nat Baz-      where-        BazSym2KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (BazSym2 t0123456789876543210 t0123456789876543210) arg) (BazSym3 t0123456789876543210 t0123456789876543210 arg) =>-                                BazSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (BazSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = Baz t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BazSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BazSym1KindInference) ())-    data BazSym1 (t0123456789876543210 :: Nat) :: (~>) Nat ((~>) Nat Baz)-      where-        BazSym1KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (BazSym1 t0123456789876543210) arg) (BazSym2 t0123456789876543210 arg) =>-                                BazSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (BazSym1 t0123456789876543210) t0123456789876543210 = BazSym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings BazSym0 where-      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())-    data BazSym0 :: (~>) Nat ((~>) Nat ((~>) Nat Baz))-      where-        BazSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply BazSym0 arg) (BazSym1 arg) =>-                                BazSym0 t0123456789876543210-    type instance Apply BazSym0 t0123456789876543210 = BazSym1 t0123456789876543210-    type Let0123456789876543210PSym0 = Let0123456789876543210P-    type family Let0123456789876543210P where-      Let0123456789876543210P = '[]-    type Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 =-        Let0123456789876543210P wild_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210PSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym0KindInference) ())-    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym0KindInference :: forall wild_01234567898765432100123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>-                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210-    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210-    type family Let0123456789876543210P wild_0123456789876543210 where-      Let0123456789876543210P wild_0123456789876543210 = Apply (Apply (:@#@$) wild_0123456789876543210) '[]-    type Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 =-        Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym2KindInference) ())-    data Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym2KindInference :: forall wild_01234567898765432100123456789876543210-                                                           wild_01234567898765432100123456789876543210-                                                           wild_01234567898765432100123456789876543210-                                                           arg. 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 (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym1KindInference) ())-    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym1KindInference :: forall wild_01234567898765432100123456789876543210-                                                           wild_01234567898765432100123456789876543210-                                                           arg. 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 Let0123456789876543210PSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym0KindInference) ())-    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym0KindInference :: forall wild_01234567898765432100123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>-                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210-    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210-    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 where-      Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 = Apply (Apply (:@#@$) wild_0123456789876543210) (Apply (Apply (:@#@$) wild_0123456789876543210) wild_0123456789876543210)-    type Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 =-        Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym1KindInference) ())-    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym1KindInference :: forall wild_01234567898765432100123456789876543210-                                                           wild_01234567898765432100123456789876543210-                                                           arg. 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 Let0123456789876543210PSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym0KindInference) ())-    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym0KindInference :: forall wild_01234567898765432100123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>-                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210-    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210-    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 where-      Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 = Apply (Apply Tuple2Sym0 wild_0123456789876543210) wild_0123456789876543210-    type Let0123456789876543210PSym0 = Let0123456789876543210P-    type family Let0123456789876543210P where-      Let0123456789876543210P = NothingSym0-    type Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 =-        Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym2KindInference) ())-    data Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym2KindInference :: forall wild_01234567898765432100123456789876543210-                                                           wild_01234567898765432100123456789876543210-                                                           wild_01234567898765432100123456789876543210-                                                           arg. 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 (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym1KindInference) ())-    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym1KindInference :: forall wild_01234567898765432100123456789876543210-                                                           wild_01234567898765432100123456789876543210-                                                           arg. 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 Let0123456789876543210PSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210PSym0KindInference) ())-    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210PSym0KindInference :: forall wild_01234567898765432100123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>-                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210-    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210-    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 where-      Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 = Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789876543210) wild_0123456789876543210) wild_0123456789876543210)-    type Let0123456789876543210XSym1 wild_01234567898765432100123456789876543210 =-        Let0123456789876543210X wild_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210XSym0KindInference) ())-    data Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210XSym0KindInference :: forall wild_01234567898765432100123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>-                                                    Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210-    type instance Apply Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210-    type family Let0123456789876543210X wild_0123456789876543210 where-      Let0123456789876543210X wild_0123456789876543210 = Apply JustSym0 wild_0123456789876543210-    type Let0123456789876543210PSym0 = Let0123456789876543210P-    type family Let0123456789876543210P where-      Let0123456789876543210P = NothingSym0-    type FooSym1 (a0123456789876543210 :: [Nat]) =-        Foo a0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: (~>) [Nat] [Nat]-      where-        FooSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210-    type TupSym1 (a0123456789876543210 :: (Nat, Nat)) =-        Tup a0123456789876543210-    instance SuppressUnusedWarnings TupSym0 where-      suppressUnusedWarnings = snd (((,) TupSym0KindInference) ())-    data TupSym0 :: (~>) (Nat, Nat) (Nat, Nat)-      where-        TupSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply TupSym0 arg) (TupSym1 arg) =>-                                TupSym0 a0123456789876543210-    type instance Apply TupSym0 a0123456789876543210 = Tup a0123456789876543210-    type Baz_Sym1 (a0123456789876543210 :: Maybe Baz) =-        Baz_ a0123456789876543210-    instance SuppressUnusedWarnings Baz_Sym0 where-      suppressUnusedWarnings = snd (((,) Baz_Sym0KindInference) ())-    data Baz_Sym0 :: (~>) (Maybe Baz) (Maybe Baz)-      where-        Baz_Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Baz_Sym0 arg) (Baz_Sym1 arg) =>-                                 Baz_Sym0 a0123456789876543210-    type instance Apply Baz_Sym0 a0123456789876543210 = Baz_ a0123456789876543210-    type BarSym1 (a0123456789876543210 :: Maybe Nat) =-        Bar a0123456789876543210-    instance SuppressUnusedWarnings BarSym0 where-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())-    data BarSym0 :: (~>) (Maybe Nat) (Maybe Nat)-      where-        BarSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>-                                BarSym0 a0123456789876543210-    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210-    type MaybePlusSym1 (a0123456789876543210 :: Maybe Nat) =-        MaybePlus a0123456789876543210-    instance SuppressUnusedWarnings MaybePlusSym0 where-      suppressUnusedWarnings = snd (((,) MaybePlusSym0KindInference) ())-    data MaybePlusSym0 :: (~>) (Maybe Nat) (Maybe Nat)-      where-        MaybePlusSym0KindInference :: forall a0123456789876543210-                                             arg. SameKind (Apply MaybePlusSym0 arg) (MaybePlusSym1 arg) =>-                                      MaybePlusSym0 a0123456789876543210-    type instance Apply MaybePlusSym0 a0123456789876543210 = MaybePlus a0123456789876543210-    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-    type family Tup (a :: (Nat, Nat)) :: (Nat, Nat) where-      Tup '(wild_0123456789876543210,-            wild_0123456789876543210) = Let0123456789876543210PSym2 wild_0123456789876543210 wild_0123456789876543210-    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-    type family Bar (a :: Maybe Nat) :: Maybe Nat where-      Bar ( 'Just wild_0123456789876543210) = Let0123456789876543210XSym1 wild_0123456789876543210-      Bar  'Nothing = NothingSym0-    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])-    sTup ::-      forall (t :: (Nat, Nat)).-      Sing t -> Sing (Apply TupSym0 t :: (Nat, Nat))-    sBaz_ ::-      forall (t :: Maybe Baz).-      Sing t -> Sing (Apply Baz_Sym0 t :: Maybe Baz)-    sBar ::-      forall (t :: Maybe Nat).-      Sing t -> Sing (Apply BarSym0 t :: Maybe Nat)-    sMaybePlus ::-      forall (t :: Maybe Nat).-      Sing t -> Sing (Apply MaybePlusSym0 t :: Maybe Nat)-    sFoo SNil-      = let-          sP :: Sing Let0123456789876543210PSym0-          sP = SNil-        in sP-    sFoo-      (SCons (sWild_0123456789876543210 :: Sing wild_0123456789876543210)-             SNil)-      = let-          sP :: Sing (Let0123456789876543210PSym1 wild_0123456789876543210)-          sP-            = (applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    sWild_0123456789876543210))-                SNil-        in sP-    sFoo-      (SCons (sWild_0123456789876543210 :: Sing wild_0123456789876543210)-             (SCons (sWild_0123456789876543210 :: Sing wild_0123456789876543210)-                    (sWild_0123456789876543210 :: Sing wild_0123456789876543210)))-      = let-          sP ::-            Sing (Let0123456789876543210PSym3 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)-          sP-            = (applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    sWild_0123456789876543210))-                ((applySing-                    ((applySing ((singFun2 @(:@#@$)) SCons))-                       sWild_0123456789876543210))-                   sWild_0123456789876543210)-        in sP-    sTup-      (STuple2 (sWild_0123456789876543210 :: Sing wild_0123456789876543210)-               (sWild_0123456789876543210 :: Sing wild_0123456789876543210))-      = let-          sP ::-            Sing (Let0123456789876543210PSym2 wild_0123456789876543210 wild_0123456789876543210)-          sP-            = (applySing-                 ((applySing ((singFun2 @Tuple2Sym0) STuple2))-                    sWild_0123456789876543210))-                sWild_0123456789876543210-        in sP-    sBaz_ SNothing-      = let-          sP :: Sing Let0123456789876543210PSym0-          sP = SNothing-        in sP-    sBaz_-      (SJust (SBaz (sWild_0123456789876543210 :: Sing wild_0123456789876543210)-                   (sWild_0123456789876543210 :: Sing wild_0123456789876543210)-                   (sWild_0123456789876543210 :: Sing wild_0123456789876543210)))-      = let-          sP ::-            Sing (Let0123456789876543210PSym3 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)-          sP-            = (applySing ((singFun1 @JustSym0) SJust))-                ((applySing-                    ((applySing-                        ((applySing ((singFun3 @BazSym0) SBaz)) sWild_0123456789876543210))-                       sWild_0123456789876543210))-                   sWild_0123456789876543210)-        in sP-    sBar-      (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210))-      = let-          sX :: Sing (Let0123456789876543210XSym1 wild_0123456789876543210)-          sX-            = (applySing ((singFun1 @JustSym0) SJust))-                sWild_0123456789876543210-        in sX-    sBar SNothing = SNothing-    sMaybePlus (SJust (sN :: Sing n))-      = (applySing ((singFun1 @JustSym0) SJust))-          ((applySing-              ((applySing ((singFun2 @PlusSym0) sPlus))-                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-             sN)-    sMaybePlus SNothing-      = let-          sP :: Sing Let0123456789876543210PSym0-          sP = SNothing-        in sP-    instance SingI (FooSym0 :: (~>) [Nat] [Nat]) where-      sing = (singFun1 @FooSym0) sFoo-    instance SingI (TupSym0 :: (~>) (Nat, Nat) (Nat, Nat)) where-      sing = (singFun1 @TupSym0) sTup-    instance SingI (Baz_Sym0 :: (~>) (Maybe Baz) (Maybe Baz)) where-      sing = (singFun1 @Baz_Sym0) sBaz_-    instance SingI (BarSym0 :: (~>) (Maybe Nat) (Maybe Nat)) where-      sing = (singFun1 @BarSym0) sBar-    instance SingI (MaybePlusSym0 :: (~>) (Maybe Nat) (Maybe Nat)) where-      sing = (singFun1 @MaybePlusSym0) sMaybePlus-    data instance Sing :: Baz -> GHC.Types.Type-      where-        SBaz :: forall (n :: Nat) (n :: Nat) (n :: Nat).-                (Sing (n :: Nat))-                -> (Sing (n :: Nat)) -> (Sing (n :: Nat)) -> Sing (Baz n n n)-    type SBaz = (Sing :: Baz -> GHC.Types.Type)-    instance SingKind Baz where-      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) }-    instance (SingI n, SingI n, SingI n) =>-             SingI (Baz (n :: Nat) (n :: Nat) (n :: Nat)) where-      sing = ((SBaz sing) sing) sing-    instance SingI (BazSym0 :: (~>) Nat ((~>) Nat ((~>) Nat Baz))) where-      sing = (singFun3 @BazSym0) SBaz-    instance SingI (TyCon3 Baz :: (~>) Nat ((~>) Nat ((~>) Nat Baz))) where-      sing = (singFun3 @(TyCon3 Baz)) SBaz-    instance SingI d =>-             SingI (BazSym1 (d :: Nat) :: (~>) Nat ((~>) Nat Baz)) where-      sing = (singFun2 @(BazSym1 (d :: Nat))) (SBaz (sing @d))-    instance SingI d =>-             SingI (TyCon2 (Baz (d :: Nat)) :: (~>) Nat ((~>) Nat Baz)) where-      sing = (singFun2 @(TyCon2 (Baz (d :: Nat)))) (SBaz (sing @d))-    instance (SingI d, SingI d) =>-             SingI (BazSym2 (d :: Nat) (d :: Nat) :: (~>) Nat Baz) where-      sing-        = (singFun1 @(BazSym2 (d :: Nat) (d :: Nat)))-            ((SBaz (sing @d)) (sing @d))-    instance (SingI d, SingI d) =>-             SingI (TyCon1 (Baz (d :: Nat) (d :: Nat)) :: (~>) Nat Baz) where-      sing-        = (singFun1 @(TyCon1 (Baz (d :: Nat) (d :: Nat))))-            ((SBaz (sing @d)) (sing @d))
+ tests/compile-and-dump/Singletons/AsPattern.ghc88.template view
@@ -0,0 +1,395 @@+Singletons/AsPattern.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| maybePlus :: Maybe Nat -> Maybe Nat+          maybePlus (Just n) = Just (plus (Succ Zero) n)+          maybePlus p@Nothing = p+          bar :: Maybe Nat -> Maybe Nat+          bar x@(Just _) = x+          bar Nothing = Nothing+          baz_ :: Maybe Baz -> Maybe Baz+          baz_ p@Nothing = p+          baz_ p@(Just (Baz _ _ _)) = p+          tup :: (Nat, Nat) -> (Nat, Nat)+          tup p@(_, _) = p+          foo :: [Nat] -> [Nat]+          foo p@[] = p+          foo p@[_] = p+          foo p@(_ : _ : _) = p+          +          data Baz = Baz Nat Nat Nat |]+  ======>+    maybePlus :: Maybe Nat -> Maybe Nat+    maybePlus (Just n) = Just ((plus (Succ Zero)) n)+    maybePlus p@Nothing = p+    bar :: Maybe Nat -> Maybe Nat+    bar x@(Just _) = x+    bar Nothing = Nothing+    data Baz = Baz Nat Nat Nat+    baz_ :: Maybe Baz -> Maybe Baz+    baz_ p@Nothing = p+    baz_ p@(Just (Baz _ _ _)) = p+    tup :: (Nat, Nat) -> (Nat, Nat)+    tup p@(_, _) = p+    foo :: [Nat] -> [Nat]+    foo p@[] = p+    foo p@[_] = p+    foo p@(_ : (_ : _)) = p+    type BazSym3 (t0123456789876543210 :: Nat) (t0123456789876543210 :: Nat) (t0123456789876543210 :: Nat) =+        Baz t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BazSym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BazSym2KindInference) ())+    data BazSym2 (t0123456789876543210 :: Nat) (t0123456789876543210 :: Nat) :: (~>) Nat Baz+      where+        BazSym2KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (BazSym2 t0123456789876543210 t0123456789876543210) arg) (BazSym3 t0123456789876543210 t0123456789876543210 arg) =>+                                BazSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (BazSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = Baz t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BazSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BazSym1KindInference) ())+    data BazSym1 (t0123456789876543210 :: Nat) :: (~>) Nat ((~>) Nat Baz)+      where+        BazSym1KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (BazSym1 t0123456789876543210) arg) (BazSym2 t0123456789876543210 arg) =>+                                BazSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (BazSym1 t0123456789876543210) t0123456789876543210 = BazSym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings BazSym0 where+      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())+    data BazSym0 :: (~>) Nat ((~>) Nat ((~>) Nat Baz))+      where+        BazSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply BazSym0 arg) (BazSym1 arg) =>+                                BazSym0 t0123456789876543210+    type instance Apply BazSym0 t0123456789876543210 = BazSym1 t0123456789876543210+    type Let0123456789876543210PSym0 = Let0123456789876543210P+    type family Let0123456789876543210P where+      Let0123456789876543210P = '[]+    type Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 =+        Let0123456789876543210P wild_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210PSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym0KindInference) ())+    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym0KindInference :: forall wild_01234567898765432100123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>+                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210+    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210P wild_01234567898765432100123456789876543210+    type family Let0123456789876543210P wild_0123456789876543210 where+      Let0123456789876543210P wild_0123456789876543210 = Apply (Apply (:@#@$) wild_0123456789876543210) '[]+    type Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 =+        Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym2KindInference) ())+    data Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym2KindInference :: forall wild_01234567898765432100123456789876543210+                                                           wild_01234567898765432100123456789876543210+                                                           wild_01234567898765432100123456789876543210+                                                           arg. 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 (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym1KindInference) ())+    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym1KindInference :: forall wild_01234567898765432100123456789876543210+                                                           wild_01234567898765432100123456789876543210+                                                           arg. 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 Let0123456789876543210PSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym0KindInference) ())+    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym0KindInference :: forall wild_01234567898765432100123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>+                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210+    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210+    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 where+      Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 = Apply (Apply (:@#@$) wild_0123456789876543210) (Apply (Apply (:@#@$) wild_0123456789876543210) wild_0123456789876543210)+    type Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 =+        Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym1KindInference) ())+    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym1KindInference :: forall wild_01234567898765432100123456789876543210+                                                           wild_01234567898765432100123456789876543210+                                                           arg. 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 Let0123456789876543210PSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym0KindInference) ())+    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym0KindInference :: forall wild_01234567898765432100123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>+                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210+    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210+    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 where+      Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 = Apply (Apply Tuple2Sym0 wild_0123456789876543210) wild_0123456789876543210+    type Let0123456789876543210PSym0 = Let0123456789876543210P+    type family Let0123456789876543210P where+      Let0123456789876543210P = NothingSym0+    type Let0123456789876543210PSym3 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 =+        Let0123456789876543210P wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym2KindInference) ())+    data Let0123456789876543210PSym2 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym2KindInference :: forall wild_01234567898765432100123456789876543210+                                                           wild_01234567898765432100123456789876543210+                                                           wild_01234567898765432100123456789876543210+                                                           arg. 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 (Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym1KindInference) ())+    data Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym1KindInference :: forall wild_01234567898765432100123456789876543210+                                                           wild_01234567898765432100123456789876543210+                                                           arg. 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 Let0123456789876543210PSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210PSym0KindInference) ())+    data Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210PSym0KindInference :: forall wild_01234567898765432100123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210PSym0 arg) (Let0123456789876543210PSym1 arg) =>+                                                    Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210+    type instance Apply Let0123456789876543210PSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210PSym1 wild_01234567898765432100123456789876543210+    type family Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 where+      Let0123456789876543210P wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210 = Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789876543210) wild_0123456789876543210) wild_0123456789876543210)+    type Let0123456789876543210XSym1 wild_01234567898765432100123456789876543210 =+        Let0123456789876543210X wild_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210XSym0KindInference) ())+    data Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210XSym0KindInference :: forall wild_01234567898765432100123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>+                                                    Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210+    type instance Apply Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210+    type family Let0123456789876543210X wild_0123456789876543210 where+      Let0123456789876543210X wild_0123456789876543210 = Apply JustSym0 wild_0123456789876543210+    type Let0123456789876543210PSym0 = Let0123456789876543210P+    type family Let0123456789876543210P where+      Let0123456789876543210P = NothingSym0+    type FooSym1 (a0123456789876543210 :: [Nat]) =+        Foo a0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: (~>) [Nat] [Nat]+      where+        FooSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 a0123456789876543210+    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210+    type TupSym1 (a0123456789876543210 :: (Nat, Nat)) =+        Tup a0123456789876543210+    instance SuppressUnusedWarnings TupSym0 where+      suppressUnusedWarnings = snd (((,) TupSym0KindInference) ())+    data TupSym0 :: (~>) (Nat, Nat) (Nat, Nat)+      where+        TupSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply TupSym0 arg) (TupSym1 arg) =>+                                TupSym0 a0123456789876543210+    type instance Apply TupSym0 a0123456789876543210 = Tup a0123456789876543210+    type Baz_Sym1 (a0123456789876543210 :: Maybe Baz) =+        Baz_ a0123456789876543210+    instance SuppressUnusedWarnings Baz_Sym0 where+      suppressUnusedWarnings = snd (((,) Baz_Sym0KindInference) ())+    data Baz_Sym0 :: (~>) (Maybe Baz) (Maybe Baz)+      where+        Baz_Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Baz_Sym0 arg) (Baz_Sym1 arg) =>+                                 Baz_Sym0 a0123456789876543210+    type instance Apply Baz_Sym0 a0123456789876543210 = Baz_ a0123456789876543210+    type BarSym1 (a0123456789876543210 :: Maybe Nat) =+        Bar a0123456789876543210+    instance SuppressUnusedWarnings BarSym0 where+      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())+    data BarSym0 :: (~>) (Maybe Nat) (Maybe Nat)+      where+        BarSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>+                                BarSym0 a0123456789876543210+    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210+    type MaybePlusSym1 (a0123456789876543210 :: Maybe Nat) =+        MaybePlus a0123456789876543210+    instance SuppressUnusedWarnings MaybePlusSym0 where+      suppressUnusedWarnings = snd (((,) MaybePlusSym0KindInference) ())+    data MaybePlusSym0 :: (~>) (Maybe Nat) (Maybe Nat)+      where+        MaybePlusSym0KindInference :: forall a0123456789876543210+                                             arg. SameKind (Apply MaybePlusSym0 arg) (MaybePlusSym1 arg) =>+                                      MaybePlusSym0 a0123456789876543210+    type instance Apply MaybePlusSym0 a0123456789876543210 = MaybePlus a0123456789876543210+    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+    type family Tup (a :: (Nat, Nat)) :: (Nat, Nat) where+      Tup '(wild_0123456789876543210,+            wild_0123456789876543210) = Let0123456789876543210PSym2 wild_0123456789876543210 wild_0123456789876543210+    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+    type family Bar (a :: Maybe Nat) :: Maybe Nat where+      Bar ('Just wild_0123456789876543210) = Let0123456789876543210XSym1 wild_0123456789876543210+      Bar 'Nothing = NothingSym0+    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])+    sTup ::+      forall (t :: (Nat, Nat)).+      Sing t -> Sing (Apply TupSym0 t :: (Nat, Nat))+    sBaz_ ::+      forall (t :: Maybe Baz).+      Sing t -> Sing (Apply Baz_Sym0 t :: Maybe Baz)+    sBar ::+      forall (t :: Maybe Nat).+      Sing t -> Sing (Apply BarSym0 t :: Maybe Nat)+    sMaybePlus ::+      forall (t :: Maybe Nat).+      Sing t -> Sing (Apply MaybePlusSym0 t :: Maybe Nat)+    sFoo SNil+      = let+          sP :: Sing Let0123456789876543210PSym0+          sP = SNil+        in sP+    sFoo+      (SCons (sWild_0123456789876543210 :: Sing wild_0123456789876543210)+             SNil)+      = let+          sP :: Sing (Let0123456789876543210PSym1 wild_0123456789876543210)+          sP+            = (applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    sWild_0123456789876543210))+                SNil+        in sP+    sFoo+      (SCons (sWild_0123456789876543210 :: Sing wild_0123456789876543210)+             (SCons (sWild_0123456789876543210 :: Sing wild_0123456789876543210)+                    (sWild_0123456789876543210 :: Sing wild_0123456789876543210)))+      = let+          sP ::+            Sing (Let0123456789876543210PSym3 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)+          sP+            = (applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    sWild_0123456789876543210))+                ((applySing+                    ((applySing ((singFun2 @(:@#@$)) SCons))+                       sWild_0123456789876543210))+                   sWild_0123456789876543210)+        in sP+    sTup+      (STuple2 (sWild_0123456789876543210 :: Sing wild_0123456789876543210)+               (sWild_0123456789876543210 :: Sing wild_0123456789876543210))+      = let+          sP ::+            Sing (Let0123456789876543210PSym2 wild_0123456789876543210 wild_0123456789876543210)+          sP+            = (applySing+                 ((applySing ((singFun2 @Tuple2Sym0) STuple2))+                    sWild_0123456789876543210))+                sWild_0123456789876543210+        in sP+    sBaz_ SNothing+      = let+          sP :: Sing Let0123456789876543210PSym0+          sP = SNothing+        in sP+    sBaz_+      (SJust (SBaz (sWild_0123456789876543210 :: Sing wild_0123456789876543210)+                   (sWild_0123456789876543210 :: Sing wild_0123456789876543210)+                   (sWild_0123456789876543210 :: Sing wild_0123456789876543210)))+      = let+          sP ::+            Sing (Let0123456789876543210PSym3 wild_0123456789876543210 wild_0123456789876543210 wild_0123456789876543210)+          sP+            = (applySing ((singFun1 @JustSym0) SJust))+                ((applySing+                    ((applySing+                        ((applySing ((singFun3 @BazSym0) SBaz)) sWild_0123456789876543210))+                       sWild_0123456789876543210))+                   sWild_0123456789876543210)+        in sP+    sBar+      (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210))+      = let+          sX :: Sing (Let0123456789876543210XSym1 wild_0123456789876543210)+          sX+            = (applySing ((singFun1 @JustSym0) SJust))+                sWild_0123456789876543210+        in sX+    sBar SNothing = SNothing+    sMaybePlus (SJust (sN :: Sing n))+      = (applySing ((singFun1 @JustSym0) SJust))+          ((applySing+              ((applySing ((singFun2 @PlusSym0) sPlus))+                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+             sN)+    sMaybePlus SNothing+      = let+          sP :: Sing Let0123456789876543210PSym0+          sP = SNothing+        in sP+    instance SingI (FooSym0 :: (~>) [Nat] [Nat]) where+      sing = (singFun1 @FooSym0) sFoo+    instance SingI (TupSym0 :: (~>) (Nat, Nat) (Nat, Nat)) where+      sing = (singFun1 @TupSym0) sTup+    instance SingI (Baz_Sym0 :: (~>) (Maybe Baz) (Maybe Baz)) where+      sing = (singFun1 @Baz_Sym0) sBaz_+    instance SingI (BarSym0 :: (~>) (Maybe Nat) (Maybe Nat)) where+      sing = (singFun1 @BarSym0) sBar+    instance SingI (MaybePlusSym0 :: (~>) (Maybe Nat) (Maybe Nat)) where+      sing = (singFun1 @MaybePlusSym0) sMaybePlus+    data SBaz :: Baz -> GHC.Types.Type+      where+        SBaz :: forall (n :: Nat) (n :: Nat) (n :: Nat).+                (Sing (n :: Nat))+                -> (Sing (n :: Nat)) -> (Sing (n :: Nat)) -> SBaz (Baz n n n)+    type instance Sing @Baz = SBaz+    instance SingKind Baz where+      type Demote Baz = Baz+      fromSing (SBaz b b b)+        = ((Baz (fromSing b)) (fromSing b)) (fromSing b)+      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) }+    instance (SingI n, SingI n, SingI n) =>+             SingI (Baz (n :: Nat) (n :: Nat) (n :: Nat)) where+      sing = ((SBaz sing) sing) sing+    instance SingI (BazSym0 :: (~>) Nat ((~>) Nat ((~>) Nat Baz))) where+      sing = (singFun3 @BazSym0) SBaz+    instance SingI d =>+             SingI (BazSym1 (d :: Nat) :: (~>) Nat ((~>) Nat Baz)) where+      sing = (singFun2 @(BazSym1 (d :: Nat))) (SBaz (sing @d))+    instance (SingI d, SingI d) =>+             SingI (BazSym2 (d :: Nat) (d :: Nat) :: (~>) Nat Baz) where+      sing+        = (singFun1 @(BazSym2 (d :: Nat) (d :: Nat)))+            ((SBaz (sing @d)) (sing @d))
− tests/compile-and-dump/Singletons/BadBoundedDeriving.ghc86.template 
@@ -1,6 +0,0 @@--Singletons/BadBoundedDeriving.hs:0:0: error:-    Can't derive Bounded instance for Foo_0 a_1.-  |-5 | $(singletons [d|-  |   ^^^^^^^^^^^^^^...
+ tests/compile-and-dump/Singletons/BadBoundedDeriving.ghc88.template view
@@ -0,0 +1,6 @@++Singletons/BadBoundedDeriving.hs:0:0: error:+    Can't derive Bounded instance for Foo_0 a_1.+  |+5 | $(singletons [d|+  |   ^^^^^^^^^^^^^^...
− tests/compile-and-dump/Singletons/BadEnumDeriving.ghc86.template 
@@ -1,6 +0,0 @@--Singletons/BadEnumDeriving.hs:0:0: error:-    Can't derive Enum instance for Foo_0 a_1.-  |-5 | $(singletons [d|-  |   ^^^^^^^^^^^^^^...
+ tests/compile-and-dump/Singletons/BadEnumDeriving.ghc88.template view
@@ -0,0 +1,6 @@++Singletons/BadEnumDeriving.hs:0:0: error:+    Can't derive Enum instance for Foo_0 a_1.+  |+5 | $(singletons [d|+  |   ^^^^^^^^^^^^^^...
− tests/compile-and-dump/Singletons/BoundedDeriving.ghc86.template 
@@ -1,249 +0,0 @@-Singletons/BoundedDeriving.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Foo1-            = Foo1-            deriving Bounded-          data Foo2-            = A | B | C | D | E-            deriving Bounded-          data Foo3 a-            = Foo3 a-            deriving Bounded-          data Foo4 (a :: Type) (b :: Type)-            = Foo41 | Foo42-            deriving Bounded-          data Pair-            = Pair Bool Bool-            deriving Bounded |]-  ======>-    data Foo1-      = Foo1-      deriving Bounded-    data Foo2-      = A | B | C | D | E-      deriving Bounded-    data Foo3 a-      = Foo3 a-      deriving Bounded-    data Foo4 (a :: Type) (b :: Type)-      = Foo41 | Foo42-      deriving Bounded-    data Pair-      = Pair Bool Bool-      deriving Bounded-    type Foo1Sym0 = Foo1-    type ASym0 = A-    type BSym0 = B-    type CSym0 = C-    type DSym0 = D-    type ESym0 = E-    type Foo3Sym1 (t0123456789876543210 :: a0123456789876543210) =-        Foo3 t0123456789876543210-    instance SuppressUnusedWarnings Foo3Sym0 where-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())-    data Foo3Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 (Foo3 a0123456789876543210)-      where-        Foo3Sym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>-                                 Foo3Sym0 t0123456789876543210-    type instance Apply Foo3Sym0 t0123456789876543210 = Foo3 t0123456789876543210-    type Foo41Sym0 = Foo41-    type Foo42Sym0 = Foo42-    type PairSym2 (t0123456789876543210 :: Bool) (t0123456789876543210 :: Bool) =-        Pair t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (PairSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())-    data PairSym1 (t0123456789876543210 :: Bool) :: (~>) Bool Pair-      where-        PairSym1KindInference :: forall t0123456789876543210-                                        t0123456789876543210-                                        arg. SameKind (Apply (PairSym1 t0123456789876543210) arg) (PairSym2 t0123456789876543210 arg) =>-                                 PairSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (PairSym1 t0123456789876543210) t0123456789876543210 = Pair t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings PairSym0 where-      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())-    data PairSym0 :: (~>) Bool ((~>) Bool Pair)-      where-        PairSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply PairSym0 arg) (PairSym1 arg) =>-                                 PairSym0 t0123456789876543210-    type instance Apply PairSym0 t0123456789876543210 = PairSym1 t0123456789876543210-    type family MinBound_0123456789876543210 :: Foo1 where-      MinBound_0123456789876543210 = Foo1Sym0-    type MinBound_0123456789876543210Sym0 =-        MinBound_0123456789876543210-    type family MaxBound_0123456789876543210 :: Foo1 where-      MaxBound_0123456789876543210 = Foo1Sym0-    type MaxBound_0123456789876543210Sym0 =-        MaxBound_0123456789876543210-    instance PBounded Foo1 where-      type MinBound = MinBound_0123456789876543210Sym0-      type MaxBound = MaxBound_0123456789876543210Sym0-    type family MinBound_0123456789876543210 :: Foo2 where-      MinBound_0123456789876543210 = ASym0-    type MinBound_0123456789876543210Sym0 =-        MinBound_0123456789876543210-    type family MaxBound_0123456789876543210 :: Foo2 where-      MaxBound_0123456789876543210 = ESym0-    type MaxBound_0123456789876543210Sym0 =-        MaxBound_0123456789876543210-    instance PBounded Foo2 where-      type MinBound = MinBound_0123456789876543210Sym0-      type MaxBound = MaxBound_0123456789876543210Sym0-    type family MinBound_0123456789876543210 :: Foo3 a where-      MinBound_0123456789876543210 = Apply Foo3Sym0 MinBoundSym0-    type MinBound_0123456789876543210Sym0 =-        MinBound_0123456789876543210-    type family MaxBound_0123456789876543210 :: Foo3 a where-      MaxBound_0123456789876543210 = Apply Foo3Sym0 MaxBoundSym0-    type MaxBound_0123456789876543210Sym0 =-        MaxBound_0123456789876543210-    instance PBounded (Foo3 a) where-      type MinBound = MinBound_0123456789876543210Sym0-      type MaxBound = MaxBound_0123456789876543210Sym0-    type family MinBound_0123456789876543210 :: Foo4 a b where-      MinBound_0123456789876543210 = Foo41Sym0-    type MinBound_0123456789876543210Sym0 =-        MinBound_0123456789876543210-    type family MaxBound_0123456789876543210 :: Foo4 a b where-      MaxBound_0123456789876543210 = Foo42Sym0-    type MaxBound_0123456789876543210Sym0 =-        MaxBound_0123456789876543210-    instance PBounded (Foo4 a b) where-      type MinBound = MinBound_0123456789876543210Sym0-      type MaxBound = MaxBound_0123456789876543210Sym0-    type family MinBound_0123456789876543210 :: Pair where-      MinBound_0123456789876543210 = Apply (Apply PairSym0 MinBoundSym0) MinBoundSym0-    type MinBound_0123456789876543210Sym0 =-        MinBound_0123456789876543210-    type family MaxBound_0123456789876543210 :: Pair where-      MaxBound_0123456789876543210 = Apply (Apply PairSym0 MaxBoundSym0) MaxBoundSym0-    type MaxBound_0123456789876543210Sym0 =-        MaxBound_0123456789876543210-    instance PBounded Pair where-      type MinBound = MinBound_0123456789876543210Sym0-      type MaxBound = MaxBound_0123456789876543210Sym0-    data instance Sing :: Foo1 -> Type where SFoo1 :: Sing Foo1-    type SFoo1 = (Sing :: Foo1 -> Type)-    instance SingKind Foo1 where-      type Demote Foo1 = Foo1-      fromSing SFoo1 = Foo1-      toSing Foo1 = SomeSing SFoo1-    data instance Sing :: Foo2 -> Type-      where-        SA :: Sing A-        SB :: Sing B-        SC :: Sing C-        SD :: Sing D-        SE :: Sing E-    type SFoo2 = (Sing :: Foo2 -> Type)-    instance SingKind Foo2 where-      type Demote Foo2 = Foo2-      fromSing SA = A-      fromSing SB = B-      fromSing SC = C-      fromSing SD = D-      fromSing SE = E-      toSing A = SomeSing SA-      toSing B = SomeSing SB-      toSing C = SomeSing SC-      toSing D = SomeSing SD-      toSing E = SomeSing SE-    data instance Sing :: Foo3 a -> Type-      where SFoo3 :: forall a (n :: a). (Sing (n :: a)) -> Sing (Foo3 n)-    type SFoo3 = (Sing :: Foo3 a -> Type)-    instance SingKind a => SingKind (Foo3 a) where-      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) }-    data instance Sing :: Foo4 a b -> Type-      where-        SFoo41 :: Sing Foo41-        SFoo42 :: Sing Foo42-    type SFoo4 = (Sing :: Foo4 a b -> Type)-    instance (SingKind a, SingKind b) => SingKind (Foo4 a b) where-      type Demote (Foo4 a b) = Foo4 (Demote a) (Demote b)-      fromSing SFoo41 = Foo41-      fromSing SFoo42 = Foo42-      toSing Foo41 = SomeSing SFoo41-      toSing Foo42 = SomeSing SFoo42-    data instance Sing :: Pair -> Type-      where-        SPair :: forall (n :: Bool) (n :: Bool).-                 (Sing (n :: Bool)) -> (Sing (n :: Bool)) -> Sing (Pair n n)-    type SPair = (Sing :: Pair -> Type)-    instance SingKind Pair where-      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) }-    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-      sMaxBound-        = (applySing ((applySing ((singFun2 @PairSym0) SPair)) sMaxBound))-            sMaxBound-    instance SingI Foo1 where-      sing = SFoo1-    instance SingI A where-      sing = SA-    instance SingI B where-      sing = SB-    instance SingI C where-      sing = SC-    instance SingI D where-      sing = SD-    instance SingI E where-      sing = SE-    instance SingI n => SingI (Foo3 (n :: a)) where-      sing = SFoo3 sing-    instance SingI (Foo3Sym0 :: (~>) a (Foo3 a)) where-      sing = (singFun1 @Foo3Sym0) SFoo3-    instance SingI (TyCon1 Foo3 :: (~>) a (Foo3 a)) where-      sing = (singFun1 @(TyCon1 Foo3)) SFoo3-    instance SingI Foo41 where-      sing = SFoo41-    instance SingI Foo42 where-      sing = SFoo42-    instance (SingI n, SingI n) =>-             SingI (Pair (n :: Bool) (n :: Bool)) where-      sing = (SPair sing) sing-    instance SingI (PairSym0 :: (~>) Bool ((~>) Bool Pair)) where-      sing = (singFun2 @PairSym0) SPair-    instance SingI (TyCon2 Pair :: (~>) Bool ((~>) Bool Pair)) where-      sing = (singFun2 @(TyCon2 Pair)) SPair-    instance SingI d =>-             SingI (PairSym1 (d :: Bool) :: (~>) Bool Pair) where-      sing = (singFun1 @(PairSym1 (d :: Bool))) (SPair (sing @d))-    instance SingI d =>-             SingI (TyCon1 (Pair (d :: Bool)) :: (~>) Bool Pair) where-      sing = (singFun1 @(TyCon1 (Pair (d :: Bool)))) (SPair (sing @d))
+ tests/compile-and-dump/Singletons/BoundedDeriving.ghc88.template view
@@ -0,0 +1,242 @@+Singletons/BoundedDeriving.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Foo1+            = Foo1+            deriving Bounded+          data Foo2+            = A | B | C | D | E+            deriving Bounded+          data Foo3 a+            = Foo3 a+            deriving Bounded+          data Foo4 (a :: Type) (b :: Type)+            = Foo41 | Foo42+            deriving Bounded+          data Pair+            = Pair Bool Bool+            deriving Bounded |]+  ======>+    data Foo1+      = Foo1+      deriving Bounded+    data Foo2+      = A | B | C | D | E+      deriving Bounded+    data Foo3 a+      = Foo3 a+      deriving Bounded+    data Foo4 (a :: Type) (b :: Type)+      = Foo41 | Foo42+      deriving Bounded+    data Pair+      = Pair Bool Bool+      deriving Bounded+    type Foo1Sym0 = Foo1+    type ASym0 = A+    type BSym0 = B+    type CSym0 = C+    type DSym0 = D+    type ESym0 = E+    type Foo3Sym1 (t0123456789876543210 :: a0123456789876543210) =+        Foo3 t0123456789876543210+    instance SuppressUnusedWarnings Foo3Sym0 where+      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())+    data Foo3Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 (Foo3 a0123456789876543210)+      where+        Foo3Sym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>+                                 Foo3Sym0 t0123456789876543210+    type instance Apply Foo3Sym0 t0123456789876543210 = Foo3 t0123456789876543210+    type Foo41Sym0 = Foo41+    type Foo42Sym0 = Foo42+    type PairSym2 (t0123456789876543210 :: Bool) (t0123456789876543210 :: Bool) =+        Pair t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (PairSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())+    data PairSym1 (t0123456789876543210 :: Bool) :: (~>) Bool Pair+      where+        PairSym1KindInference :: forall t0123456789876543210+                                        t0123456789876543210+                                        arg. SameKind (Apply (PairSym1 t0123456789876543210) arg) (PairSym2 t0123456789876543210 arg) =>+                                 PairSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (PairSym1 t0123456789876543210) t0123456789876543210 = Pair t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings PairSym0 where+      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())+    data PairSym0 :: (~>) Bool ((~>) Bool Pair)+      where+        PairSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply PairSym0 arg) (PairSym1 arg) =>+                                 PairSym0 t0123456789876543210+    type instance Apply PairSym0 t0123456789876543210 = PairSym1 t0123456789876543210+    type family MinBound_0123456789876543210 :: Foo1 where+      MinBound_0123456789876543210 = Foo1Sym0+    type MinBound_0123456789876543210Sym0 =+        MinBound_0123456789876543210+    type family MaxBound_0123456789876543210 :: Foo1 where+      MaxBound_0123456789876543210 = Foo1Sym0+    type MaxBound_0123456789876543210Sym0 =+        MaxBound_0123456789876543210+    instance PBounded Foo1 where+      type MinBound = MinBound_0123456789876543210Sym0+      type MaxBound = MaxBound_0123456789876543210Sym0+    type family MinBound_0123456789876543210 :: Foo2 where+      MinBound_0123456789876543210 = ASym0+    type MinBound_0123456789876543210Sym0 =+        MinBound_0123456789876543210+    type family MaxBound_0123456789876543210 :: Foo2 where+      MaxBound_0123456789876543210 = ESym0+    type MaxBound_0123456789876543210Sym0 =+        MaxBound_0123456789876543210+    instance PBounded Foo2 where+      type MinBound = MinBound_0123456789876543210Sym0+      type MaxBound = MaxBound_0123456789876543210Sym0+    type family MinBound_0123456789876543210 :: Foo3 a where+      MinBound_0123456789876543210 = Apply Foo3Sym0 MinBoundSym0+    type MinBound_0123456789876543210Sym0 =+        MinBound_0123456789876543210+    type family MaxBound_0123456789876543210 :: Foo3 a where+      MaxBound_0123456789876543210 = Apply Foo3Sym0 MaxBoundSym0+    type MaxBound_0123456789876543210Sym0 =+        MaxBound_0123456789876543210+    instance PBounded (Foo3 a) where+      type MinBound = MinBound_0123456789876543210Sym0+      type MaxBound = MaxBound_0123456789876543210Sym0+    type family MinBound_0123456789876543210 :: Foo4 a b where+      MinBound_0123456789876543210 = Foo41Sym0+    type MinBound_0123456789876543210Sym0 =+        MinBound_0123456789876543210+    type family MaxBound_0123456789876543210 :: Foo4 a b where+      MaxBound_0123456789876543210 = Foo42Sym0+    type MaxBound_0123456789876543210Sym0 =+        MaxBound_0123456789876543210+    instance PBounded (Foo4 a b) where+      type MinBound = MinBound_0123456789876543210Sym0+      type MaxBound = MaxBound_0123456789876543210Sym0+    type family MinBound_0123456789876543210 :: Pair where+      MinBound_0123456789876543210 = Apply (Apply PairSym0 MinBoundSym0) MinBoundSym0+    type MinBound_0123456789876543210Sym0 =+        MinBound_0123456789876543210+    type family MaxBound_0123456789876543210 :: Pair where+      MaxBound_0123456789876543210 = Apply (Apply PairSym0 MaxBoundSym0) MaxBoundSym0+    type MaxBound_0123456789876543210Sym0 =+        MaxBound_0123456789876543210+    instance PBounded Pair where+      type MinBound = MinBound_0123456789876543210Sym0+      type MaxBound = MaxBound_0123456789876543210Sym0+    data SFoo1 :: Foo1 -> Type where SFoo1 :: SFoo1 Foo1+    type instance Sing @Foo1 = SFoo1+    instance SingKind Foo1 where+      type Demote Foo1 = Foo1+      fromSing SFoo1 = Foo1+      toSing Foo1 = SomeSing SFoo1+    data SFoo2 :: Foo2 -> Type+      where+        SA :: SFoo2 A+        SB :: SFoo2 B+        SC :: SFoo2 C+        SD :: SFoo2 D+        SE :: SFoo2 E+    type instance Sing @Foo2 = SFoo2+    instance SingKind Foo2 where+      type Demote Foo2 = Foo2+      fromSing SA = A+      fromSing SB = B+      fromSing SC = C+      fromSing SD = D+      fromSing SE = E+      toSing A = SomeSing SA+      toSing B = SomeSing SB+      toSing C = SomeSing SC+      toSing D = SomeSing SD+      toSing E = SomeSing SE+    data SFoo3 :: forall a. Foo3 a -> Type+      where SFoo3 :: forall a (n :: a). (Sing (n :: a)) -> SFoo3 (Foo3 n)+    type instance Sing @(Foo3 a) = SFoo3+    instance SingKind a => SingKind (Foo3 a) where+      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) }+    data SFoo4 :: forall a b. Foo4 a b -> Type+      where+        SFoo41 :: SFoo4 Foo41+        SFoo42 :: SFoo4 Foo42+    type instance Sing @(Foo4 a b) = SFoo4+    instance (SingKind a, SingKind b) => SingKind (Foo4 a b) where+      type Demote (Foo4 a b) = Foo4 (Demote a) (Demote b)+      fromSing SFoo41 = Foo41+      fromSing SFoo42 = Foo42+      toSing Foo41 = SomeSing SFoo41+      toSing Foo42 = SomeSing SFoo42+    data SPair :: Pair -> Type+      where+        SPair :: forall (n :: Bool) (n :: Bool).+                 (Sing (n :: Bool)) -> (Sing (n :: Bool)) -> SPair (Pair n n)+    type instance Sing @Pair = SPair+    instance SingKind Pair where+      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) }+    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+      sMaxBound+        = (applySing ((applySing ((singFun2 @PairSym0) SPair)) sMaxBound))+            sMaxBound+    instance SingI Foo1 where+      sing = SFoo1+    instance SingI A where+      sing = SA+    instance SingI B where+      sing = SB+    instance SingI C where+      sing = SC+    instance SingI D where+      sing = SD+    instance SingI E where+      sing = SE+    instance SingI n => SingI (Foo3 (n :: a)) where+      sing = SFoo3 sing+    instance SingI (Foo3Sym0 :: (~>) a (Foo3 a)) where+      sing = (singFun1 @Foo3Sym0) SFoo3+    instance SingI Foo41 where+      sing = SFoo41+    instance SingI Foo42 where+      sing = SFoo42+    instance (SingI n, SingI n) =>+             SingI (Pair (n :: Bool) (n :: Bool)) where+      sing = (SPair sing) sing+    instance SingI (PairSym0 :: (~>) Bool ((~>) Bool Pair)) where+      sing = (singFun2 @PairSym0) SPair+    instance SingI d =>+             SingI (PairSym1 (d :: Bool) :: (~>) Bool Pair) where+      sing = (singFun1 @(PairSym1 (d :: Bool))) (SPair (sing @d))
− tests/compile-and-dump/Singletons/BoxUnBox.ghc86.template 
@@ -1,54 +0,0 @@-Singletons/BoxUnBox.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| unBox :: Box a -> a-          unBox (FBox a) = a-          -          data Box a = FBox a |]-  ======>-    data Box a = FBox a-    unBox :: Box a -> a-    unBox (FBox a) = a-    type FBoxSym1 (t0123456789876543210 :: a0123456789876543210) =-        FBox t0123456789876543210-    instance SuppressUnusedWarnings FBoxSym0 where-      suppressUnusedWarnings = snd (((,) FBoxSym0KindInference) ())-    data FBoxSym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 (Box a0123456789876543210)-      where-        FBoxSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply FBoxSym0 arg) (FBoxSym1 arg) =>-                                 FBoxSym0 t0123456789876543210-    type instance Apply FBoxSym0 t0123456789876543210 = FBox t0123456789876543210-    type UnBoxSym1 (a0123456789876543210 :: Box a0123456789876543210) =-        UnBox a0123456789876543210-    instance SuppressUnusedWarnings UnBoxSym0 where-      suppressUnusedWarnings = snd (((,) UnBoxSym0KindInference) ())-    data UnBoxSym0 :: forall a0123456789876543210.-                      (~>) (Box a0123456789876543210) a0123456789876543210-      where-        UnBoxSym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply UnBoxSym0 arg) (UnBoxSym1 arg) =>-                                  UnBoxSym0 a0123456789876543210-    type instance Apply UnBoxSym0 a0123456789876543210 = UnBox a0123456789876543210-    type family UnBox (a :: Box a) :: a where-      UnBox (FBox a) = a-    sUnBox ::-      forall a (t :: Box a). Sing t -> Sing (Apply UnBoxSym0 t :: a)-    sUnBox (SFBox (sA :: Sing a)) = sA-    instance SingI (UnBoxSym0 :: (~>) (Box a) a) where-      sing = (singFun1 @UnBoxSym0) sUnBox-    data instance Sing :: Box a -> GHC.Types.Type-      where SFBox :: forall a (n :: a). (Sing (n :: a)) -> Sing (FBox n)-    type SBox = (Sing :: Box a -> GHC.Types.Type)-    instance SingKind a => SingKind (Box a) where-      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) }-    instance SingI n => SingI (FBox (n :: a)) where-      sing = SFBox sing-    instance SingI (FBoxSym0 :: (~>) a (Box a)) where-      sing = (singFun1 @FBoxSym0) SFBox-    instance SingI (TyCon1 FBox :: (~>) a (Box a)) where-      sing = (singFun1 @(TyCon1 FBox)) SFBox
+ tests/compile-and-dump/Singletons/BoxUnBox.ghc88.template view
@@ -0,0 +1,52 @@+Singletons/BoxUnBox.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| unBox :: Box a -> a+          unBox (FBox a) = a+          +          data Box a = FBox a |]+  ======>+    data Box a = FBox a+    unBox :: Box a -> a+    unBox (FBox a) = a+    type FBoxSym1 (t0123456789876543210 :: a0123456789876543210) =+        FBox t0123456789876543210+    instance SuppressUnusedWarnings FBoxSym0 where+      suppressUnusedWarnings = snd (((,) FBoxSym0KindInference) ())+    data FBoxSym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 (Box a0123456789876543210)+      where+        FBoxSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply FBoxSym0 arg) (FBoxSym1 arg) =>+                                 FBoxSym0 t0123456789876543210+    type instance Apply FBoxSym0 t0123456789876543210 = FBox t0123456789876543210+    type UnBoxSym1 (a0123456789876543210 :: Box a0123456789876543210) =+        UnBox a0123456789876543210+    instance SuppressUnusedWarnings UnBoxSym0 where+      suppressUnusedWarnings = snd (((,) UnBoxSym0KindInference) ())+    data UnBoxSym0 :: forall a0123456789876543210.+                      (~>) (Box a0123456789876543210) a0123456789876543210+      where+        UnBoxSym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply UnBoxSym0 arg) (UnBoxSym1 arg) =>+                                  UnBoxSym0 a0123456789876543210+    type instance Apply UnBoxSym0 a0123456789876543210 = UnBox a0123456789876543210+    type family UnBox (a :: Box a) :: a where+      UnBox (FBox a) = a+    sUnBox ::+      forall a (t :: Box a). Sing t -> Sing (Apply UnBoxSym0 t :: a)+    sUnBox (SFBox (sA :: Sing a)) = sA+    instance SingI (UnBoxSym0 :: (~>) (Box a) a) where+      sing = (singFun1 @UnBoxSym0) sUnBox+    data SBox :: forall a. Box a -> GHC.Types.Type+      where SFBox :: forall a (n :: a). (Sing (n :: a)) -> SBox (FBox n)+    type instance Sing @(Box a) = SBox+    instance SingKind a => SingKind (Box a) where+      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) }+    instance SingI n => SingI (FBox (n :: a)) where+      sing = SFBox sing+    instance SingI (FBoxSym0 :: (~>) a (Box a)) where+      sing = (singFun1 @FBoxSym0) SFBox
− tests/compile-and-dump/Singletons/CaseExpressions.ghc86.template 
@@ -1,319 +0,0 @@-Singletons/CaseExpressions.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo1 :: a -> Maybe a -> a-          foo1 d x-            = case x of-                Just y -> y-                Nothing -> d-          foo2 :: a -> Maybe a -> a-          foo2 d _ = case (Just d) of { Just y -> y }-          foo3 :: a -> b -> a-          foo3 a b = case (a, b) of { (p, _) -> p }-          foo4 :: forall a. a -> a-          foo4 x-            = case x of {-                y -> let-                       z :: a-                       z = y-                     in z }-          foo5 :: a -> a-          foo5 x = case x of { y -> (\ _ -> x) y } |]-  ======>-    foo1 :: a -> Maybe a -> a-    foo1 d x-      = case x of-          Just y -> y-          Nothing -> d-    foo2 :: a -> Maybe a -> a-    foo2 d _ = case Just d of { Just y -> y }-    foo3 :: a -> b -> a-    foo3 a b = case (a, b) of { (p, _) -> p }-    foo4 :: forall a. a -> a-    foo4 x-      = case x of {-          y -> let-                 z :: a-                 z = y-               in z }-    foo5 :: a -> a-    foo5 x = case x of { y -> (\ _ -> x) y }-    type family Case_0123456789876543210 x y arg_0123456789876543210 t where-      Case_0123456789876543210 x y arg_0123456789876543210 _ = x-    type family Lambda_0123456789876543210 x y t where-      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 x y arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Case_0123456789876543210 x t where-      Case_0123456789876543210 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y-    type Let0123456789876543210ZSym2 x0123456789876543210 y0123456789876543210 =-        Let0123456789876543210Z x0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym1KindInference) ())-    data Let0123456789876543210ZSym1 x0123456789876543210 y0123456789876543210-      where-        Let0123456789876543210ZSym1KindInference :: forall x0123456789876543210-                                                           y0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210ZSym1 x0123456789876543210) arg) (Let0123456789876543210ZSym2 x0123456789876543210 arg) =>-                                                    Let0123456789876543210ZSym1 x0123456789876543210 y0123456789876543210-    type instance Apply (Let0123456789876543210ZSym1 x0123456789876543210) y0123456789876543210 = Let0123456789876543210Z x0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())-    data Let0123456789876543210ZSym0 x0123456789876543210-      where-        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 x0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210ZSym1 x0123456789876543210-    type family Let0123456789876543210Z x y :: a where-      Let0123456789876543210Z x y = y-    type family Case_0123456789876543210 x t where-      Case_0123456789876543210 x y = Let0123456789876543210ZSym2 x y-    type Let0123456789876543210Scrutinee_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 =-        Let0123456789876543210Scrutinee_0123456789876543210 a0123456789876543210 b0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                                       b0123456789876543210-                                                                                       arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 a b where-      Let0123456789876543210Scrutinee_0123456789876543210 a b = Apply (Apply Tuple2Sym0 a) b-    type family Case_0123456789876543210 a b t where-      Case_0123456789876543210 a b '(p, _) = p-    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 d0123456789876543210 =-        Let0123456789876543210Scrutinee_0123456789876543210 d0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall d0123456789876543210-                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 d0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 d where-      Let0123456789876543210Scrutinee_0123456789876543210 d = Apply JustSym0 d-    type family Case_0123456789876543210 d t where-      Case_0123456789876543210 d ( 'Just y) = y-    type family Case_0123456789876543210 d x t where-      Case_0123456789876543210 d x ( 'Just y) = y-      Case_0123456789876543210 d x  'Nothing = d-    type Foo5Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Foo5 a0123456789876543210-    instance SuppressUnusedWarnings Foo5Sym0 where-      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())-    data Foo5Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 a0123456789876543210-      where-        Foo5Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>-                                 Foo5Sym0 a0123456789876543210-    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210-    type Foo4Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Foo4 a0123456789876543210-    instance SuppressUnusedWarnings Foo4Sym0 where-      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())-    data Foo4Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 a0123456789876543210-      where-        Foo4Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>-                                 Foo4Sym0 a0123456789876543210-    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210-    type Foo3Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo3 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo3Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo3Sym1KindInference) ())-    data Foo3Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 a0123456789876543210-      where-        Foo3Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo3Sym1 a0123456789876543210) arg) (Foo3Sym2 a0123456789876543210 arg) =>-                                 Foo3Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo3Sym1 a0123456789876543210) a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo3Sym0 where-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())-    data Foo3Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        Foo3Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>-                                 Foo3Sym0 a0123456789876543210-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3Sym1 a0123456789876543210-    type Foo2Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =-        Foo2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())-    data Foo2Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) a0123456789876543210-      where-        Foo2Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>-                                 Foo2Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo2Sym0 where-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())-    data Foo2Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) a0123456789876543210)-      where-        Foo2Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>-                                 Foo2Sym0 a0123456789876543210-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210-    type Foo1Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =-        Foo1 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())-    data Foo1Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) a0123456789876543210-      where-        Foo1Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>-                                 Foo1Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo1Sym0 where-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())-    data Foo1Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) a0123456789876543210)-      where-        Foo1Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>-                                 Foo1Sym0 a0123456789876543210-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210-    type family Foo5 (a :: a) :: a where-      Foo5 x = Case_0123456789876543210 x x-    type family Foo4 (a :: a) :: a where-      Foo4 x = Case_0123456789876543210 x x-    type family Foo3 (a :: a) (a :: b) :: a where-      Foo3 a b = Case_0123456789876543210 a b (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b)-    type family Foo2 (a :: a) (a :: Maybe a) :: a where-      Foo2 d _ = Case_0123456789876543210 d (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d)-    type family Foo1 (a :: a) (a :: Maybe a) :: a where-      Foo1 d x = Case_0123456789876543210 d x x-    sFoo5 :: forall a (t :: a). Sing t -> Sing (Apply Foo5Sym0 t :: a)-    sFoo4 :: forall a (t :: a). Sing t -> Sing (Apply Foo4Sym0 t :: a)-    sFoo3 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a)-    sFoo2 ::-      forall a (t :: a) (t :: Maybe a).-      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)-    sFoo1 ::-      forall a (t :: a) (t :: Maybe a).-      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)-    sFoo5 (sX :: Sing x)-      = (case sX of {-           (sY :: Sing y)-             -> (applySing-                   ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y))-                      (\ sArg_0123456789876543210-                         -> case sArg_0123456789876543210 of {-                              (_ :: Sing arg_0123456789876543210)-                                -> (case sArg_0123456789876543210 of { _ -> sX }) ::-                                     Sing (Case_0123456789876543210 x y arg_0123456789876543210 arg_0123456789876543210) })))-                  sY }) ::-          Sing (Case_0123456789876543210 x x :: a)-    sFoo4 (sX :: Sing x)-      = (case sX of {-           (sY :: Sing y)-             -> let-                  sZ :: Sing (Let0123456789876543210ZSym2 x y :: a)-                  sZ = sY-                in sZ }) ::-          Sing (Case_0123456789876543210 x x :: a)-    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  (case sScrutinee_0123456789876543210 of {-               STuple2 (sP :: Sing p) _ -> sP }) ::-              Sing (Case_0123456789876543210 a b (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b) :: a)-    sFoo2 (sD :: Sing d) _-      = let-          sScrutinee_0123456789876543210 ::-            Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d)-          sScrutinee_0123456789876543210-            = (applySing ((singFun1 @JustSym0) SJust)) sD-        in  (case sScrutinee_0123456789876543210 of {-               SJust (sY :: Sing y) -> sY }) ::-              Sing (Case_0123456789876543210 d (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d) :: a)-    sFoo1 (sD :: Sing d) (sX :: Sing x)-      = (case sX of-           SJust (sY :: Sing y) -> sY-           SNothing -> sD) ::-          Sing (Case_0123456789876543210 d x x :: a)-    instance SingI (Foo5Sym0 :: (~>) a a) where-      sing = (singFun1 @Foo5Sym0) sFoo5-    instance SingI (Foo4Sym0 :: (~>) a a) where-      sing = (singFun1 @Foo4Sym0) sFoo4-    instance SingI (Foo3Sym0 :: (~>) a ((~>) b a)) where-      sing = (singFun2 @Foo3Sym0) sFoo3-    instance SingI d => SingI (Foo3Sym1 (d :: a) :: (~>) b a) where-      sing = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 (sing @d))-    instance SingI (Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)) where-      sing = (singFun2 @Foo2Sym0) sFoo2-    instance SingI d =>-             SingI (Foo2Sym1 (d :: a) :: (~>) (Maybe a) a) where-      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))-    instance SingI (Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)) where-      sing = (singFun2 @Foo1Sym0) sFoo1-    instance SingI d =>-             SingI (Foo1Sym1 (d :: a) :: (~>) (Maybe a) a) where-      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))
+ tests/compile-and-dump/Singletons/CaseExpressions.ghc88.template view
@@ -0,0 +1,324 @@+Singletons/CaseExpressions.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo1 :: a -> Maybe a -> a+          foo1 d x+            = case x of+                Just y -> y+                Nothing -> d+          foo2 :: a -> Maybe a -> a+          foo2 d _ = case (Just d) of { Just y -> y }+          foo3 :: a -> b -> a+          foo3 a b = case (a, b) of { (p, _) -> p }+          foo4 :: forall a. a -> a+          foo4 x+            = case x of {+                y -> let+                       z :: a+                       z = y+                     in z }+          foo5 :: a -> a+          foo5 x = case x of { y -> (\ _ -> x) y } |]+  ======>+    foo1 :: a -> Maybe a -> a+    foo1 d x+      = case x of+          Just y -> y+          Nothing -> d+    foo2 :: a -> Maybe a -> a+    foo2 d _ = case Just d of { Just y -> y }+    foo3 :: a -> b -> a+    foo3 a b = case (a, b) of { (p, _) -> p }+    foo4 :: forall a. a -> a+    foo4 x+      = case x of {+          y -> let+                 z :: a+                 z = y+               in z }+    foo5 :: a -> a+    foo5 x = case x of { y -> (\ _ -> x) y }+    type family Case_0123456789876543210 arg_0123456789876543210 y x t where+      Case_0123456789876543210 arg_0123456789876543210 y x _ = x+    type family Lambda_0123456789876543210 y x t where+      Lambda_0123456789876543210 y x arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 y x arg_0123456789876543210+    type Lambda_0123456789876543210Sym3 y0123456789876543210 x0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall y0123456789876543210+                                                              x0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym3 y0123456789876543210 x0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 y0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 y0123456789876543210 x0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall y0123456789876543210+                                                              x0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 y0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall y0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 y0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 y0123456789876543210 = Lambda_0123456789876543210Sym1 y0123456789876543210+    type family Case_0123456789876543210 x t where+      Case_0123456789876543210 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 y) x) y+    type Let0123456789876543210ZSym2 y0123456789876543210 x0123456789876543210 =+        Let0123456789876543210Z y0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 y0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym1KindInference) ())+    data Let0123456789876543210ZSym1 y0123456789876543210 x0123456789876543210+      where+        Let0123456789876543210ZSym1KindInference :: forall y0123456789876543210+                                                           x0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210ZSym1 y0123456789876543210) arg) (Let0123456789876543210ZSym2 y0123456789876543210 arg) =>+                                                    Let0123456789876543210ZSym1 y0123456789876543210 x0123456789876543210+    type instance Apply (Let0123456789876543210ZSym1 y0123456789876543210) x0123456789876543210 = Let0123456789876543210Z y0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym0KindInference) ())+    data Let0123456789876543210ZSym0 y0123456789876543210+      where+        Let0123456789876543210ZSym0KindInference :: forall y0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>+                                                    Let0123456789876543210ZSym0 y0123456789876543210+    type instance Apply Let0123456789876543210ZSym0 y0123456789876543210 = Let0123456789876543210ZSym1 y0123456789876543210+    type family Let0123456789876543210Z y x :: a where+      Let0123456789876543210Z y x = y+    type family Case_0123456789876543210 x t where+      Case_0123456789876543210 x y = Let0123456789876543210ZSym2 y x+    type Let0123456789876543210Scrutinee_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 =+        Let0123456789876543210Scrutinee_0123456789876543210 a0123456789876543210 b0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                                       b0123456789876543210+                                                                                       arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 a0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210Sym1 a0123456789876543210+    type family Let0123456789876543210Scrutinee_0123456789876543210 a b where+      Let0123456789876543210Scrutinee_0123456789876543210 a b = Apply (Apply Tuple2Sym0 a) b+    type family Case_0123456789876543210 a b t where+      Case_0123456789876543210 a b '(p, _) = p+    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 d0123456789876543210 =+        Let0123456789876543210Scrutinee_0123456789876543210 d0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall d0123456789876543210+                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210+    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 d0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 d0123456789876543210+    type family Let0123456789876543210Scrutinee_0123456789876543210 d where+      Let0123456789876543210Scrutinee_0123456789876543210 d = Apply JustSym0 d+    type family Case_0123456789876543210 d t where+      Case_0123456789876543210 d ('Just y) = y+    type family Case_0123456789876543210 d x t where+      Case_0123456789876543210 d x ('Just y) = y+      Case_0123456789876543210 d x 'Nothing = d+    type Foo5Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Foo5 a0123456789876543210+    instance SuppressUnusedWarnings Foo5Sym0 where+      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())+    data Foo5Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 a0123456789876543210+      where+        Foo5Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>+                                 Foo5Sym0 a0123456789876543210+    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210+    type Foo4Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Foo4 a0123456789876543210+    instance SuppressUnusedWarnings Foo4Sym0 where+      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())+    data Foo4Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 a0123456789876543210+      where+        Foo4Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>+                                 Foo4Sym0 a0123456789876543210+    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210+    type Foo3Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo3 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo3Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo3Sym1KindInference) ())+    data Foo3Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 a0123456789876543210+      where+        Foo3Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo3Sym1 a0123456789876543210) arg) (Foo3Sym2 a0123456789876543210 arg) =>+                                 Foo3Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo3Sym1 a0123456789876543210) a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo3Sym0 where+      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())+    data Foo3Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        Foo3Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>+                                 Foo3Sym0 a0123456789876543210+    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3Sym1 a0123456789876543210+    type Foo2Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =+        Foo2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())+    data Foo2Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) a0123456789876543210+      where+        Foo2Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>+                                 Foo2Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo2Sym0 where+      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())+    data Foo2Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) a0123456789876543210)+      where+        Foo2Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>+                                 Foo2Sym0 a0123456789876543210+    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210+    type Foo1Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =+        Foo1 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())+    data Foo1Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) a0123456789876543210+      where+        Foo1Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>+                                 Foo1Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo1Sym0 where+      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())+    data Foo1Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) a0123456789876543210)+      where+        Foo1Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>+                                 Foo1Sym0 a0123456789876543210+    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210+    type family Foo5 (a :: a) :: a where+      Foo5 x = Case_0123456789876543210 x x+    type family Foo4 (a :: a) :: a where+      Foo4 x = Case_0123456789876543210 x x+    type family Foo3 (a :: a) (a :: b) :: a where+      Foo3 a b = Case_0123456789876543210 a b (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b)+    type family Foo2 (a :: a) (a :: Maybe a) :: a where+      Foo2 d _ = Case_0123456789876543210 d (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d)+    type family Foo1 (a :: a) (a :: Maybe a) :: a where+      Foo1 d x = Case_0123456789876543210 d x x+    sFoo5 :: forall a (t :: a). Sing t -> Sing (Apply Foo5Sym0 t :: a)+    sFoo4 :: forall a (t :: a). Sing t -> Sing (Apply Foo4Sym0 t :: a)+    sFoo3 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a)+    sFoo2 ::+      forall a (t :: a) (t :: Maybe a).+      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)+    sFoo1 ::+      forall a (t :: a) (t :: Maybe a).+      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)+    sFoo5 (sX :: Sing x)+      = (id @(Sing (Case_0123456789876543210 x x :: a)))+          (case sX of {+             (sY :: Sing y)+               -> (applySing+                     ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 y) x))+                        (\ sArg_0123456789876543210+                           -> case sArg_0123456789876543210 of {+                                (_ :: Sing arg_0123456789876543210)+                                  -> (id+                                        @(Sing (Case_0123456789876543210 arg_0123456789876543210 y x arg_0123456789876543210)))+                                       (case sArg_0123456789876543210 of { _ -> sX }) })))+                    sY })+    sFoo4 (sX :: Sing x)+      = (id @(Sing (Case_0123456789876543210 x x :: a)))+          (case sX of {+             (sY :: Sing y)+               -> let+                    sZ :: Sing (Let0123456789876543210ZSym2 y x :: a)+                    sZ = sY+                  in sZ })+    sFoo3 (sA :: Sing a) (sB :: Sing b)+      = let+          sScrutinee_0123456789876543210 ::+            Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b)+          sScrutinee_0123456789876543210+            = (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sA)) sB+        in+          (id+             @(Sing (Case_0123456789876543210 a b (Let0123456789876543210Scrutinee_0123456789876543210Sym2 a b) :: a)))+            (case sScrutinee_0123456789876543210 of {+               STuple2 (sP :: Sing p) _ -> sP })+    sFoo2 (sD :: Sing d) _+      = let+          sScrutinee_0123456789876543210 ::+            Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d)+          sScrutinee_0123456789876543210+            = (applySing ((singFun1 @JustSym0) SJust)) sD+        in+          (id+             @(Sing (Case_0123456789876543210 d (Let0123456789876543210Scrutinee_0123456789876543210Sym1 d) :: a)))+            (case sScrutinee_0123456789876543210 of {+               SJust (sY :: Sing y) -> sY })+    sFoo1 (sD :: Sing d) (sX :: Sing x)+      = (id @(Sing (Case_0123456789876543210 d x x :: a)))+          (case sX of+             SJust (sY :: Sing y) -> sY+             SNothing -> sD)+    instance SingI (Foo5Sym0 :: (~>) a a) where+      sing = (singFun1 @Foo5Sym0) sFoo5+    instance SingI (Foo4Sym0 :: (~>) a a) where+      sing = (singFun1 @Foo4Sym0) sFoo4+    instance SingI (Foo3Sym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @Foo3Sym0) sFoo3+    instance SingI d => SingI (Foo3Sym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 (sing @d))+    instance SingI (Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)) where+      sing = (singFun2 @Foo2Sym0) sFoo2+    instance SingI d =>+             SingI (Foo2Sym1 (d :: a) :: (~>) (Maybe a) a) where+      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))+    instance SingI (Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)) where+      sing = (singFun2 @Foo1Sym0) sFoo1+    instance SingI d =>+             SingI (Foo1Sym1 (d :: a) :: (~>) (Maybe a) a) where+      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))
− tests/compile-and-dump/Singletons/Classes.ghc86.template 
@@ -1,577 +0,0 @@-Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| infix 4 <=>-          -          const :: a -> b -> a-          const x _ = x-          fooCompare :: Foo -> Foo -> Ordering-          fooCompare A A = EQ-          fooCompare A B = LT-          fooCompare B B = GT-          fooCompare B A = EQ-          -          class MyOrd a where-            mycompare :: a -> a -> Ordering-            (<=>) :: a -> a -> Ordering-            (<=>) = mycompare-            infix 4 <=>-          data Foo = A | B-          data Foo2 = F | G-          -          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 |]-  ======>-    const :: a -> b -> a-    const x _ = x-    class MyOrd a where-      mycompare :: a -> a -> Ordering-      (<=>) :: a -> a -> Ordering-      (<=>) = mycompare-    infix 4 <=>-    instance MyOrd Nat where-      mycompare Zero Zero = EQ-      mycompare Zero (Succ _) = LT-      mycompare (Succ _) Zero = GT-      mycompare (Succ n) (Succ m) = (m `mycompare` n)-    instance MyOrd () where-      mycompare _ = const EQ-    data Foo = A | B-    fooCompare :: Foo -> Foo -> Ordering-    fooCompare A A = EQ-    fooCompare A B = LT-    fooCompare B B = GT-    fooCompare B A = EQ-    instance MyOrd Foo where-      mycompare = fooCompare-    data Foo2 = F | G-    instance Eq Foo2 where-      (==) F F = True-      (==) G G = True-      (==) F G = False-      (==) G F = False-    type ASym0 = A-    type BSym0 = B-    type FSym0 = F-    type GSym0 = G-    type FooCompareSym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) =-        FooCompare a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (FooCompareSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FooCompareSym1KindInference) ())-    data FooCompareSym1 (a0123456789876543210 :: Foo) :: (~>) Foo Ordering-      where-        FooCompareSym1KindInference :: forall a0123456789876543210-                                              a0123456789876543210-                                              arg. SameKind (Apply (FooCompareSym1 a0123456789876543210) arg) (FooCompareSym2 a0123456789876543210 arg) =>-                                       FooCompareSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (FooCompareSym1 a0123456789876543210) a0123456789876543210 = FooCompare a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings FooCompareSym0 where-      suppressUnusedWarnings = snd (((,) FooCompareSym0KindInference) ())-    data FooCompareSym0 :: (~>) Foo ((~>) Foo Ordering)-      where-        FooCompareSym0KindInference :: forall a0123456789876543210-                                              arg. SameKind (Apply FooCompareSym0 arg) (FooCompareSym1 arg) =>-                                       FooCompareSym0 a0123456789876543210-    type instance Apply FooCompareSym0 a0123456789876543210 = FooCompareSym1 a0123456789876543210-    type ConstSym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Const a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ConstSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ConstSym1KindInference) ())-    data ConstSym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                     (~>) b0123456789876543210 a0123456789876543210-      where-        ConstSym1KindInference :: forall a0123456789876543210-                                         a0123456789876543210-                                         arg. SameKind (Apply (ConstSym1 a0123456789876543210) arg) (ConstSym2 a0123456789876543210 arg) =>-                                  ConstSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (ConstSym1 a0123456789876543210) a0123456789876543210 = Const a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ConstSym0 where-      suppressUnusedWarnings = snd (((,) ConstSym0KindInference) ())-    data ConstSym0 :: forall a0123456789876543210 b0123456789876543210.-                      (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        ConstSym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply ConstSym0 arg) (ConstSym1 arg) =>-                                  ConstSym0 a0123456789876543210-    type instance Apply ConstSym0 a0123456789876543210 = ConstSym1 a0123456789876543210-    type family FooCompare (a :: Foo) (a :: Foo) :: Ordering where-      FooCompare A A = EQSym0-      FooCompare A B = LTSym0-      FooCompare B B = GTSym0-      FooCompare B A = EQSym0-    type family Const (a :: a) (a :: b) :: a where-      Const x _ = x-    type MycompareSym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =-        Mycompare arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (MycompareSym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MycompareSym1KindInference) ())-    data MycompareSym1 (arg0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 Ordering-      where-        MycompareSym1KindInference :: forall arg0123456789876543210-                                             arg0123456789876543210-                                             arg. SameKind (Apply (MycompareSym1 arg0123456789876543210) arg) (MycompareSym2 arg0123456789876543210 arg) =>-                                      MycompareSym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (MycompareSym1 arg0123456789876543210) arg0123456789876543210 = Mycompare arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings MycompareSym0 where-      suppressUnusedWarnings = snd (((,) MycompareSym0KindInference) ())-    data MycompareSym0 :: forall a0123456789876543210.-                          (~>) a0123456789876543210 ((~>) a0123456789876543210 Ordering)-      where-        MycompareSym0KindInference :: forall arg0123456789876543210-                                             arg. SameKind (Apply MycompareSym0 arg) (MycompareSym1 arg) =>-                                      MycompareSym0 arg0123456789876543210-    type instance Apply MycompareSym0 arg0123456789876543210 = MycompareSym1 arg0123456789876543210-    type (<=>@#@$$$) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =-        (<=>) arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings ((<=>@#@$$) arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:<=>@#@$$###)) ())-    data (<=>@#@$$) (arg0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 Ordering-      where-        (:<=>@#@$$###) :: forall arg0123456789876543210-                                 arg0123456789876543210-                                 arg. SameKind (Apply ((<=>@#@$$) arg0123456789876543210) arg) ((<=>@#@$$$) arg0123456789876543210 arg) =>-                          (<=>@#@$$) arg0123456789876543210 arg0123456789876543210-    type instance Apply ((<=>@#@$$) arg0123456789876543210) arg0123456789876543210 = (<=>) arg0123456789876543210 arg0123456789876543210-    infix 4 <=>@#@$$-    instance SuppressUnusedWarnings (<=>@#@$) where-      suppressUnusedWarnings = snd (((,) (:<=>@#@$###)) ())-    data (<=>@#@$) :: forall a0123456789876543210.-                      (~>) a0123456789876543210 ((~>) a0123456789876543210 Ordering)-      where-        (:<=>@#@$###) :: forall arg0123456789876543210-                                arg. SameKind (Apply (<=>@#@$) arg) ((<=>@#@$$) arg) =>-                         (<=>@#@$) arg0123456789876543210-    type instance Apply (<=>@#@$) arg0123456789876543210 = (<=>@#@$$) arg0123456789876543210-    infix 4 <=>@#@$-    type family TFHelper_0123456789876543210 (a :: a) (a :: a) :: Ordering where-      TFHelper_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply MycompareSym0 a_0123456789876543210) a_0123456789876543210-    type TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: a0123456789876543210) =-        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 Ordering-      where-        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())-    data TFHelper_0123456789876543210Sym0 :: forall a0123456789876543210.-                                             (~>) a0123456789876543210 ((~>) a0123456789876543210 Ordering)-      where-        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210-    class PMyOrd (a :: GHC.Types.Type) where-      type Mycompare (arg :: a) (arg :: a) :: Ordering-      type (<=>) (arg :: a) (arg :: a) :: Ordering-      type (<=>) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a-    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_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering-      where-        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())-    data Mycompare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)-      where-        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210-    instance PMyOrd Nat where-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a-    type family Mycompare_0123456789876543210 (a :: ()) (a :: ()) :: Ordering where-      Mycompare_0123456789876543210 _ a_0123456789876543210 = Apply (Apply ConstSym0 EQSym0) a_0123456789876543210-    type Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: ()) (a0123456789876543210 :: ()) =-        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: ()) :: (~>) () Ordering-      where-        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())-    data Mycompare_0123456789876543210Sym0 :: (~>) () ((~>) () Ordering)-      where-        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210-    instance PMyOrd () where-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a-    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_0123456789876543210Sym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) =-        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: (~>) Foo Ordering-      where-        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())-    data Mycompare_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Ordering)-      where-        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210-    instance PMyOrd Foo where-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a-    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_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) =-        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Bool-      where-        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())-    data TFHelper_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Bool)-      where-        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210-    instance PEq Foo2 where-      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a-    infix 4 %<=>-    sFooCompare ::-      forall (t :: Foo) (t :: Foo).-      Sing t-      -> Sing t -> Sing (Apply (Apply FooCompareSym0 t) t :: Ordering)-    sConst ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply ConstSym0 t) t :: a)-    sFooCompare SA SA = SEQ-    sFooCompare SA SB = SLT-    sFooCompare SB SB = SGT-    sFooCompare SB SA = SEQ-    sConst (sX :: Sing x) _ = sX-    instance SingI (FooCompareSym0 :: (~>) Foo ((~>) Foo Ordering)) where-      sing = (singFun2 @FooCompareSym0) sFooCompare-    instance SingI d =>-             SingI (FooCompareSym1 (d :: Foo) :: (~>) Foo Ordering) where-      sing-        = (singFun1 @(FooCompareSym1 (d :: Foo))) (sFooCompare (sing @d))-    instance SingI (ConstSym0 :: (~>) a ((~>) b a)) where-      sing = (singFun2 @ConstSym0) sConst-    instance SingI d => SingI (ConstSym1 (d :: a) :: (~>) b a) where-      sing = (singFun1 @(ConstSym1 (d :: a))) (sConst (sing @d))-    data instance Sing :: Foo -> GHC.Types.Type-      where-        SA :: Sing A-        SB :: Sing B-    type SFoo = (Sing :: Foo -> GHC.Types.Type)-    instance SingKind Foo where-      type Demote Foo = Foo-      fromSing SA = A-      fromSing SB = B-      toSing A = SomeSing SA-      toSing B = SomeSing SB-    data instance Sing :: Foo2 -> GHC.Types.Type-      where-        SF :: Sing F-        SG :: Sing G-    type SFoo2 = (Sing :: Foo2 -> GHC.Types.Type)-    instance SingKind Foo2 where-      type Demote Foo2 = Foo2-      fromSing SF = F-      fromSing SG = G-      toSing F = SomeSing SF-      toSing G = SomeSing SG-    class SMyOrd a where-      sMycompare ::-        forall (t :: a) (t :: a).-        Sing t-        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)-      (%<=>) ::-        forall (t :: a) (t :: a).-        Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering)-      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)-      (%<=>)-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @MycompareSym0) sMycompare))-                sA_0123456789876543210))-            sA_0123456789876543210-    instance SMyOrd Nat where-      sMycompare ::-        forall (t :: Nat) (t :: Nat).-        Sing t-        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)-      sMycompare SZero SZero = SEQ-      sMycompare SZero (SSucc _) = SLT-      sMycompare (SSucc _) SZero = SGT-      sMycompare (SSucc (sN :: Sing n)) (SSucc (sM :: Sing m))-        = (applySing-             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))-            sN-    instance SMyOrd () where-      sMycompare ::-        forall (t :: ()) (t :: ()).-        Sing t-        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)-      sMycompare _ (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing ((applySing ((singFun2 @ConstSym0) sConst)) SEQ))-            sA_0123456789876543210-    instance SMyOrd Foo where-      sMycompare ::-        forall (t :: Foo) (t :: Foo).-        Sing t-        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)-      sMycompare-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @FooCompareSym0) sFooCompare))-                sA_0123456789876543210))-            sA_0123456789876543210-    instance SEq Foo2 where-      (%==) ::-        forall (a :: Foo2) (b :: Foo2). Sing a -> Sing b -> Sing ((==) a b)-      (%==) SF SF = STrue-      (%==) SG SG = STrue-      (%==) SF SG = SFalse-      (%==) SG SF = SFalse-    instance SingI A where-      sing = SA-    instance SingI B where-      sing = SB-    instance SingI F where-      sing = SF-    instance SingI G where-      sing = SG-    instance SMyOrd a =>-             SingI (MycompareSym0 :: (~>) a ((~>) a Ordering)) where-      sing = (singFun2 @MycompareSym0) sMycompare-    instance (SMyOrd a, SingI d) =>-             SingI (MycompareSym1 (d :: a) :: (~>) a Ordering) where-      sing = (singFun1 @(MycompareSym1 (d :: a))) (sMycompare (sing @d))-    instance SMyOrd a =>-             SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where-      sing = (singFun2 @(<=>@#@$)) (%<=>)-    instance (SMyOrd a, SingI d) =>-             SingI ((<=>@#@$$) (d :: a) :: (~>) a Ordering) where-      sing = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) (sing @d))-Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations-    promote-      [d| instance Ord Foo2 where-            F `compare` F = EQ-            F `compare` _ = LT-            _ `compare` _ = GT-          instance MyOrd Foo2 where-            F `mycompare` F = EQ-            F `mycompare` _ = LT-            _ `mycompare` _ = GT |]-  ======>-    instance MyOrd Foo2 where-      mycompare F F = EQ-      mycompare F _ = LT-      mycompare _ _ = GT-    instance Ord Foo2 where-      compare F F = EQ-      compare F _ = LT-      compare _ _ = GT-    type family Mycompare_0123456789876543210 (a :: Foo2) (a :: Foo2) :: Ordering where-      Mycompare_0123456789876543210  'F  'F = EQSym0-      Mycompare_0123456789876543210  'F _ = LTSym0-      Mycompare_0123456789876543210 _ _ = GTSym0-    type Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) =-        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Ordering-      where-        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())-    data Mycompare_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Ordering)-      where-        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210-    instance PMyOrd Foo2 where-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a-    type family Compare_0123456789876543210 (a :: Foo2) (a :: Foo2) :: Ordering where-      Compare_0123456789876543210  'F  'F = EQSym0-      Compare_0123456789876543210  'F _ = LTSym0-      Compare_0123456789876543210 _ _ = GTSym0-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd Foo2 where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Nat' = Zero' | Succ' Nat'-          -          instance MyOrd Nat' where-            Zero' `mycompare` Zero' = EQ-            Zero' `mycompare` (Succ' _) = LT-            (Succ' _) `mycompare` Zero' = GT-            (Succ' n) `mycompare` (Succ' m) = m `mycompare` n |]-  ======>-    data Nat' = Zero' | Succ' Nat'-    instance MyOrd Nat' where-      mycompare Zero' Zero' = EQ-      mycompare Zero' (Succ' _) = LT-      mycompare (Succ' _) Zero' = GT-      mycompare (Succ' n) (Succ' m) = (m `mycompare` n)-    type Zero'Sym0 = Zero'-    type Succ'Sym1 (t0123456789876543210 :: Nat') =-        Succ' t0123456789876543210-    instance SuppressUnusedWarnings Succ'Sym0 where-      suppressUnusedWarnings = snd (((,) Succ'Sym0KindInference) ())-    data Succ'Sym0 :: (~>) Nat' Nat'-      where-        Succ'Sym0KindInference :: forall t0123456789876543210-                                         arg. SameKind (Apply Succ'Sym0 arg) (Succ'Sym1 arg) =>-                                  Succ'Sym0 t0123456789876543210-    type instance Apply Succ'Sym0 t0123456789876543210 = Succ' t0123456789876543210-    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_0123456789876543210Sym2 (a0123456789876543210 :: Nat') (a0123456789876543210 :: Nat') =-        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Nat') :: (~>) Nat' Ordering-      where-        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())-    data Mycompare_0123456789876543210Sym0 :: (~>) Nat' ((~>) Nat' Ordering)-      where-        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210-    instance PMyOrd Nat' where-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a-    data instance Sing :: Nat' -> GHC.Types.Type-      where-        SZero' :: Sing Zero'-        SSucc' :: forall (n :: Nat'). (Sing (n :: Nat')) -> Sing (Succ' n)-    type SNat' = (Sing :: Nat' -> GHC.Types.Type)-    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 SMyOrd Nat' where-      sMycompare ::-        forall (t :: Nat') (t :: Nat').-        Sing t-        -> Sing t-           -> Sing (Apply (Apply (MycompareSym0 :: TyFun Nat' ((~>) Nat' Ordering)-                                                   -> GHC.Types.Type) t) t)-      sMycompare SZero' SZero' = SEQ-      sMycompare SZero' (SSucc' _) = SLT-      sMycompare (SSucc' _) SZero' = SGT-      sMycompare (SSucc' (sN :: Sing n)) (SSucc' (sM :: Sing m))-        = (applySing-             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))-            sN-    instance SingI Zero' where-      sing = SZero'-    instance SingI n => SingI (Succ' (n :: Nat')) where-      sing = SSucc' sing-    instance SingI (Succ'Sym0 :: (~>) Nat' Nat') where-      sing = (singFun1 @Succ'Sym0) SSucc'-    instance SingI (TyCon1 Succ' :: (~>) Nat' Nat') where-      sing = (singFun1 @(TyCon1 Succ')) SSucc'
+ tests/compile-and-dump/Singletons/Classes.ghc88.template view
@@ -0,0 +1,575 @@+Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| infix 4 <=>+          +          const :: a -> b -> a+          const x _ = x+          fooCompare :: Foo -> Foo -> Ordering+          fooCompare A A = EQ+          fooCompare A B = LT+          fooCompare B B = GT+          fooCompare B A = EQ+          +          class MyOrd a where+            mycompare :: a -> a -> Ordering+            (<=>) :: a -> a -> Ordering+            (<=>) = mycompare+            infix 4 <=>+          data Foo = A | B+          data Foo2 = F | G+          +          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 |]+  ======>+    const :: a -> b -> a+    const x _ = x+    class MyOrd a where+      mycompare :: a -> a -> Ordering+      (<=>) :: a -> a -> Ordering+      (<=>) = mycompare+    infix 4 <=>+    instance MyOrd Nat where+      mycompare Zero Zero = EQ+      mycompare Zero (Succ _) = LT+      mycompare (Succ _) Zero = GT+      mycompare (Succ n) (Succ m) = (m `mycompare` n)+    instance MyOrd () where+      mycompare _ = const EQ+    data Foo = A | B+    fooCompare :: Foo -> Foo -> Ordering+    fooCompare A A = EQ+    fooCompare A B = LT+    fooCompare B B = GT+    fooCompare B A = EQ+    instance MyOrd Foo where+      mycompare = fooCompare+    data Foo2 = F | G+    instance Eq Foo2 where+      (==) F F = True+      (==) G G = True+      (==) F G = False+      (==) G F = False+    type ASym0 = A+    type BSym0 = B+    type FSym0 = F+    type GSym0 = G+    type FooCompareSym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) =+        FooCompare a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (FooCompareSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FooCompareSym1KindInference) ())+    data FooCompareSym1 (a0123456789876543210 :: Foo) :: (~>) Foo Ordering+      where+        FooCompareSym1KindInference :: forall a0123456789876543210+                                              a0123456789876543210+                                              arg. SameKind (Apply (FooCompareSym1 a0123456789876543210) arg) (FooCompareSym2 a0123456789876543210 arg) =>+                                       FooCompareSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (FooCompareSym1 a0123456789876543210) a0123456789876543210 = FooCompare a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings FooCompareSym0 where+      suppressUnusedWarnings = snd (((,) FooCompareSym0KindInference) ())+    data FooCompareSym0 :: (~>) Foo ((~>) Foo Ordering)+      where+        FooCompareSym0KindInference :: forall a0123456789876543210+                                              arg. SameKind (Apply FooCompareSym0 arg) (FooCompareSym1 arg) =>+                                       FooCompareSym0 a0123456789876543210+    type instance Apply FooCompareSym0 a0123456789876543210 = FooCompareSym1 a0123456789876543210+    type ConstSym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Const a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ConstSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ConstSym1KindInference) ())+    data ConstSym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                     (~>) b0123456789876543210 a0123456789876543210+      where+        ConstSym1KindInference :: forall a0123456789876543210+                                         a0123456789876543210+                                         arg. SameKind (Apply (ConstSym1 a0123456789876543210) arg) (ConstSym2 a0123456789876543210 arg) =>+                                  ConstSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (ConstSym1 a0123456789876543210) a0123456789876543210 = Const a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ConstSym0 where+      suppressUnusedWarnings = snd (((,) ConstSym0KindInference) ())+    data ConstSym0 :: forall a0123456789876543210 b0123456789876543210.+                      (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        ConstSym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply ConstSym0 arg) (ConstSym1 arg) =>+                                  ConstSym0 a0123456789876543210+    type instance Apply ConstSym0 a0123456789876543210 = ConstSym1 a0123456789876543210+    type family FooCompare (a :: Foo) (a :: Foo) :: Ordering where+      FooCompare A A = EQSym0+      FooCompare A B = LTSym0+      FooCompare B B = GTSym0+      FooCompare B A = EQSym0+    type family Const (a :: a) (a :: b) :: a where+      Const x _ = x+    type MycompareSym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =+        Mycompare arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (MycompareSym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MycompareSym1KindInference) ())+    data MycompareSym1 (arg0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 Ordering+      where+        MycompareSym1KindInference :: forall arg0123456789876543210+                                             arg0123456789876543210+                                             arg. SameKind (Apply (MycompareSym1 arg0123456789876543210) arg) (MycompareSym2 arg0123456789876543210 arg) =>+                                      MycompareSym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (MycompareSym1 arg0123456789876543210) arg0123456789876543210 = Mycompare arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings MycompareSym0 where+      suppressUnusedWarnings = snd (((,) MycompareSym0KindInference) ())+    data MycompareSym0 :: forall a0123456789876543210.+                          (~>) a0123456789876543210 ((~>) a0123456789876543210 Ordering)+      where+        MycompareSym0KindInference :: forall arg0123456789876543210+                                             arg. SameKind (Apply MycompareSym0 arg) (MycompareSym1 arg) =>+                                      MycompareSym0 arg0123456789876543210+    type instance Apply MycompareSym0 arg0123456789876543210 = MycompareSym1 arg0123456789876543210+    type (<=>@#@$$$) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =+        (<=>) arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings ((<=>@#@$$) arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:<=>@#@$$###)) ())+    data (<=>@#@$$) (arg0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 Ordering+      where+        (:<=>@#@$$###) :: forall arg0123456789876543210+                                 arg0123456789876543210+                                 arg. SameKind (Apply ((<=>@#@$$) arg0123456789876543210) arg) ((<=>@#@$$$) arg0123456789876543210 arg) =>+                          (<=>@#@$$) arg0123456789876543210 arg0123456789876543210+    type instance Apply ((<=>@#@$$) arg0123456789876543210) arg0123456789876543210 = (<=>) arg0123456789876543210 arg0123456789876543210+    infix 4 <=>@#@$$+    instance SuppressUnusedWarnings (<=>@#@$) where+      suppressUnusedWarnings = snd (((,) (:<=>@#@$###)) ())+    data (<=>@#@$) :: forall a0123456789876543210.+                      (~>) a0123456789876543210 ((~>) a0123456789876543210 Ordering)+      where+        (:<=>@#@$###) :: forall arg0123456789876543210+                                arg. SameKind (Apply (<=>@#@$) arg) ((<=>@#@$$) arg) =>+                         (<=>@#@$) arg0123456789876543210+    type instance Apply (<=>@#@$) arg0123456789876543210 = (<=>@#@$$) arg0123456789876543210+    infix 4 <=>@#@$+    type family TFHelper_0123456789876543210 (a :: a) (a :: a) :: Ordering where+      TFHelper_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply MycompareSym0 a_0123456789876543210) a_0123456789876543210+    type TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: a0123456789876543210) =+        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())+    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 Ordering+      where+        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())+    data TFHelper_0123456789876543210Sym0 :: forall a0123456789876543210.+                                             (~>) a0123456789876543210 ((~>) a0123456789876543210 Ordering)+      where+        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>+                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210+    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210+    class PMyOrd (a :: GHC.Types.Type) where+      type Mycompare (arg :: a) (arg :: a) :: Ordering+      type (<=>) (arg :: a) (arg :: a) :: Ordering+      type (<=>) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a+    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_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())+    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering+      where+        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())+    data Mycompare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)+      where+        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>+                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210+    instance PMyOrd Nat where+      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a+    type family Mycompare_0123456789876543210 (a :: ()) (a :: ()) :: Ordering where+      Mycompare_0123456789876543210 _ a_0123456789876543210 = Apply (Apply ConstSym0 EQSym0) a_0123456789876543210+    type Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: ()) (a0123456789876543210 :: ()) =+        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())+    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: ()) :: (~>) () Ordering+      where+        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())+    data Mycompare_0123456789876543210Sym0 :: (~>) () ((~>) () Ordering)+      where+        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>+                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210+    instance PMyOrd () where+      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a+    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_0123456789876543210Sym2 (a0123456789876543210 :: Foo) (a0123456789876543210 :: Foo) =+        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())+    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Foo) :: (~>) Foo Ordering+      where+        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())+    data Mycompare_0123456789876543210Sym0 :: (~>) Foo ((~>) Foo Ordering)+      where+        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>+                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210+    instance PMyOrd Foo where+      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a+    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_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) =+        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())+    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Bool+      where+        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())+    data TFHelper_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Bool)+      where+        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>+                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210+    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210+    instance PEq Foo2 where+      type (==) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a+    infix 4 %<=>+    sFooCompare ::+      forall (t :: Foo) (t :: Foo).+      Sing t+      -> Sing t -> Sing (Apply (Apply FooCompareSym0 t) t :: Ordering)+    sConst ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply ConstSym0 t) t :: a)+    sFooCompare SA SA = SEQ+    sFooCompare SA SB = SLT+    sFooCompare SB SB = SGT+    sFooCompare SB SA = SEQ+    sConst (sX :: Sing x) _ = sX+    instance SingI (FooCompareSym0 :: (~>) Foo ((~>) Foo Ordering)) where+      sing = (singFun2 @FooCompareSym0) sFooCompare+    instance SingI d =>+             SingI (FooCompareSym1 (d :: Foo) :: (~>) Foo Ordering) where+      sing+        = (singFun1 @(FooCompareSym1 (d :: Foo))) (sFooCompare (sing @d))+    instance SingI (ConstSym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @ConstSym0) sConst+    instance SingI d => SingI (ConstSym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(ConstSym1 (d :: a))) (sConst (sing @d))+    data SFoo :: Foo -> GHC.Types.Type+      where+        SA :: SFoo A+        SB :: SFoo B+    type instance Sing @Foo = SFoo+    instance SingKind Foo where+      type Demote Foo = Foo+      fromSing SA = A+      fromSing SB = B+      toSing A = SomeSing SA+      toSing B = SomeSing SB+    data SFoo2 :: Foo2 -> GHC.Types.Type+      where+        SF :: SFoo2 F+        SG :: SFoo2 G+    type instance Sing @Foo2 = SFoo2+    instance SingKind Foo2 where+      type Demote Foo2 = Foo2+      fromSing SF = F+      fromSing SG = G+      toSing F = SomeSing SF+      toSing G = SomeSing SG+    class SMyOrd a where+      sMycompare ::+        forall (t :: a) (t :: a).+        Sing t+        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)+      (%<=>) ::+        forall (t :: a) (t :: a).+        Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering)+      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)+      (%<=>)+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @MycompareSym0) sMycompare))+                sA_0123456789876543210))+            sA_0123456789876543210+    instance SMyOrd Nat where+      sMycompare ::+        forall (t :: Nat) (t :: Nat).+        Sing t+        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)+      sMycompare SZero SZero = SEQ+      sMycompare SZero (SSucc _) = SLT+      sMycompare (SSucc _) SZero = SGT+      sMycompare (SSucc (sN :: Sing n)) (SSucc (sM :: Sing m))+        = (applySing+             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))+            sN+    instance SMyOrd () where+      sMycompare ::+        forall (t :: ()) (t :: ()).+        Sing t+        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)+      sMycompare _ (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing ((applySing ((singFun2 @ConstSym0) sConst)) SEQ))+            sA_0123456789876543210+    instance SMyOrd Foo where+      sMycompare ::+        forall (t :: Foo) (t :: Foo).+        Sing t+        -> Sing t -> Sing (Apply (Apply MycompareSym0 t) t :: Ordering)+      sMycompare+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @FooCompareSym0) sFooCompare))+                sA_0123456789876543210))+            sA_0123456789876543210+    instance SEq Foo2 where+      (%==) ::+        forall (a :: Foo2) (b :: Foo2). Sing a -> Sing b -> Sing ((==) a b)+      (%==) SF SF = STrue+      (%==) SG SG = STrue+      (%==) SF SG = SFalse+      (%==) SG SF = SFalse+    instance SingI A where+      sing = SA+    instance SingI B where+      sing = SB+    instance SingI F where+      sing = SF+    instance SingI G where+      sing = SG+    instance SMyOrd a =>+             SingI (MycompareSym0 :: (~>) a ((~>) a Ordering)) where+      sing = (singFun2 @MycompareSym0) sMycompare+    instance (SMyOrd a, SingI d) =>+             SingI (MycompareSym1 (d :: a) :: (~>) a Ordering) where+      sing = (singFun1 @(MycompareSym1 (d :: a))) (sMycompare (sing @d))+    instance SMyOrd a =>+             SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where+      sing = (singFun2 @(<=>@#@$)) (%<=>)+    instance (SMyOrd a, SingI d) =>+             SingI ((<=>@#@$$) (d :: a) :: (~>) a Ordering) where+      sing = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) (sing @d))+Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations+    promote+      [d| instance Ord Foo2 where+            F `compare` F = EQ+            F `compare` _ = LT+            _ `compare` _ = GT+          instance MyOrd Foo2 where+            F `mycompare` F = EQ+            F `mycompare` _ = LT+            _ `mycompare` _ = GT |]+  ======>+    instance MyOrd Foo2 where+      mycompare F F = EQ+      mycompare F _ = LT+      mycompare _ _ = GT+    instance Ord Foo2 where+      compare F F = EQ+      compare F _ = LT+      compare _ _ = GT+    type family Mycompare_0123456789876543210 (a :: Foo2) (a :: Foo2) :: Ordering where+      Mycompare_0123456789876543210 'F 'F = EQSym0+      Mycompare_0123456789876543210 'F _ = LTSym0+      Mycompare_0123456789876543210 _ _ = GTSym0+    type Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) =+        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())+    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Ordering+      where+        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())+    data Mycompare_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Ordering)+      where+        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>+                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210+    instance PMyOrd Foo2 where+      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a+    type family Compare_0123456789876543210 (a :: Foo2) (a :: Foo2) :: Ordering where+      Compare_0123456789876543210 'F 'F = EQSym0+      Compare_0123456789876543210 'F _ = LTSym0+      Compare_0123456789876543210 _ _ = GTSym0+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Foo2) (a0123456789876543210 :: Foo2) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Foo2) :: (~>) Foo2 Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) Foo2 ((~>) Foo2 Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd Foo2 where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+Singletons/Classes.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Nat' = Zero' | Succ' Nat'+          +          instance MyOrd Nat' where+            Zero' `mycompare` Zero' = EQ+            Zero' `mycompare` (Succ' _) = LT+            (Succ' _) `mycompare` Zero' = GT+            (Succ' n) `mycompare` (Succ' m) = m `mycompare` n |]+  ======>+    data Nat' = Zero' | Succ' Nat'+    instance MyOrd Nat' where+      mycompare Zero' Zero' = EQ+      mycompare Zero' (Succ' _) = LT+      mycompare (Succ' _) Zero' = GT+      mycompare (Succ' n) (Succ' m) = (m `mycompare` n)+    type Zero'Sym0 = Zero'+    type Succ'Sym1 (t0123456789876543210 :: Nat') =+        Succ' t0123456789876543210+    instance SuppressUnusedWarnings Succ'Sym0 where+      suppressUnusedWarnings = snd (((,) Succ'Sym0KindInference) ())+    data Succ'Sym0 :: (~>) Nat' Nat'+      where+        Succ'Sym0KindInference :: forall t0123456789876543210+                                         arg. SameKind (Apply Succ'Sym0 arg) (Succ'Sym1 arg) =>+                                  Succ'Sym0 t0123456789876543210+    type instance Apply Succ'Sym0 t0123456789876543210 = Succ' t0123456789876543210+    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_0123456789876543210Sym2 (a0123456789876543210 :: Nat') (a0123456789876543210 :: Nat') =+        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())+    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: Nat') :: (~>) Nat' Ordering+      where+        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())+    data Mycompare_0123456789876543210Sym0 :: (~>) Nat' ((~>) Nat' Ordering)+      where+        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>+                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210+    instance PMyOrd Nat' where+      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a+    data SNat' :: Nat' -> GHC.Types.Type+      where+        SZero' :: SNat' Zero'+        SSucc' :: forall (n :: Nat'). (Sing (n :: Nat')) -> SNat' (Succ' n)+    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 SMyOrd Nat' where+      sMycompare ::+        forall (t :: Nat') (t :: Nat').+        Sing t+        -> Sing t+           -> Sing (Apply (Apply (MycompareSym0 :: TyFun Nat' ((~>) Nat' Ordering)+                                                   -> GHC.Types.Type) t) t)+      sMycompare SZero' SZero' = SEQ+      sMycompare SZero' (SSucc' _) = SLT+      sMycompare (SSucc' _) SZero' = SGT+      sMycompare (SSucc' (sN :: Sing n)) (SSucc' (sM :: Sing m))+        = (applySing+             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))+            sN+    instance SingI Zero' where+      sing = SZero'+    instance SingI n => SingI (Succ' (n :: Nat')) where+      sing = SSucc' sing+    instance SingI (Succ'Sym0 :: (~>) Nat' Nat') where+      sing = (singFun1 @Succ'Sym0) SSucc'
− tests/compile-and-dump/Singletons/Classes2.ghc86.template 
@@ -1,91 +0,0 @@-Singletons/Classes2.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data NatFoo = ZeroFoo | SuccFoo NatFoo-          -          instance MyOrd NatFoo where-            ZeroFoo `mycompare` ZeroFoo = EQ-            ZeroFoo `mycompare` (SuccFoo _) = LT-            (SuccFoo _) `mycompare` ZeroFoo = GT-            (SuccFoo n) `mycompare` (SuccFoo m) = m `mycompare` n |]-  ======>-    data NatFoo = ZeroFoo | SuccFoo NatFoo-    instance MyOrd NatFoo where-      mycompare ZeroFoo ZeroFoo = EQ-      mycompare ZeroFoo (SuccFoo _) = LT-      mycompare (SuccFoo _) ZeroFoo = GT-      mycompare (SuccFoo n) (SuccFoo m) = (m `mycompare` n)-    type ZeroFooSym0 = ZeroFoo-    type SuccFooSym1 (t0123456789876543210 :: NatFoo) =-        SuccFoo t0123456789876543210-    instance SuppressUnusedWarnings SuccFooSym0 where-      suppressUnusedWarnings = snd (((,) SuccFooSym0KindInference) ())-    data SuccFooSym0 :: (~>) NatFoo NatFoo-      where-        SuccFooSym0KindInference :: forall t0123456789876543210-                                           arg. SameKind (Apply SuccFooSym0 arg) (SuccFooSym1 arg) =>-                                    SuccFooSym0 t0123456789876543210-    type instance Apply SuccFooSym0 t0123456789876543210 = SuccFoo t0123456789876543210-    type family Mycompare_0123456789876543210 (a :: NatFoo) (a :: NatFoo) :: Ordering where-      Mycompare_0123456789876543210 ZeroFoo ZeroFoo = EQSym0-      Mycompare_0123456789876543210 ZeroFoo (SuccFoo _) = LTSym0-      Mycompare_0123456789876543210 (SuccFoo _) ZeroFoo = GTSym0-      Mycompare_0123456789876543210 (SuccFoo n) (SuccFoo m) = Apply (Apply MycompareSym0 m) n-    type Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: NatFoo) (a0123456789876543210 :: NatFoo) =-        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())-    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: NatFoo) :: (~>) NatFoo Ordering-      where-        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())-    data Mycompare_0123456789876543210Sym0 :: (~>) NatFoo ((~>) NatFoo Ordering)-      where-        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>-                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210-    instance PMyOrd NatFoo where-      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a-    data instance Sing :: NatFoo -> GHC.Types.Type-      where-        SZeroFoo :: Sing ZeroFoo-        SSuccFoo :: forall (n :: NatFoo).-                    (Sing (n :: NatFoo)) -> Sing (SuccFoo n)-    type SNatFoo = (Sing :: NatFoo -> GHC.Types.Type)-    instance SingKind NatFoo where-      type Demote NatFoo = NatFoo-      fromSing SZeroFoo = ZeroFoo-      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) }-    instance SMyOrd NatFoo where-      sMycompare ::-        forall (t1 :: NatFoo) (t2 :: NatFoo).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (MycompareSym0 :: TyFun NatFoo ((~>) NatFoo Ordering)-                                                   -> GHC.Types.Type) t1) t2)-      sMycompare SZeroFoo SZeroFoo = SEQ-      sMycompare SZeroFoo (SSuccFoo _) = SLT-      sMycompare (SSuccFoo _) SZeroFoo = SGT-      sMycompare (SSuccFoo (sN :: Sing n)) (SSuccFoo (sM :: Sing m))-        = (applySing-             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))-            sN-    instance SingI ZeroFoo where-      sing = SZeroFoo-    instance SingI n => SingI (SuccFoo (n :: NatFoo)) where-      sing = SSuccFoo sing-    instance SingI (SuccFooSym0 :: (~>) NatFoo NatFoo) where-      sing = (singFun1 @SuccFooSym0) SSuccFoo-    instance SingI (TyCon1 SuccFoo :: (~>) NatFoo NatFoo) where-      sing = (singFun1 @(TyCon1 SuccFoo)) SSuccFoo
+ tests/compile-and-dump/Singletons/Classes2.ghc88.template view
@@ -0,0 +1,89 @@+Singletons/Classes2.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data NatFoo = ZeroFoo | SuccFoo NatFoo+          +          instance MyOrd NatFoo where+            ZeroFoo `mycompare` ZeroFoo = EQ+            ZeroFoo `mycompare` (SuccFoo _) = LT+            (SuccFoo _) `mycompare` ZeroFoo = GT+            (SuccFoo n) `mycompare` (SuccFoo m) = m `mycompare` n |]+  ======>+    data NatFoo = ZeroFoo | SuccFoo NatFoo+    instance MyOrd NatFoo where+      mycompare ZeroFoo ZeroFoo = EQ+      mycompare ZeroFoo (SuccFoo _) = LT+      mycompare (SuccFoo _) ZeroFoo = GT+      mycompare (SuccFoo n) (SuccFoo m) = (m `mycompare` n)+    type ZeroFooSym0 = ZeroFoo+    type SuccFooSym1 (t0123456789876543210 :: NatFoo) =+        SuccFoo t0123456789876543210+    instance SuppressUnusedWarnings SuccFooSym0 where+      suppressUnusedWarnings = snd (((,) SuccFooSym0KindInference) ())+    data SuccFooSym0 :: (~>) NatFoo NatFoo+      where+        SuccFooSym0KindInference :: forall t0123456789876543210+                                           arg. SameKind (Apply SuccFooSym0 arg) (SuccFooSym1 arg) =>+                                    SuccFooSym0 t0123456789876543210+    type instance Apply SuccFooSym0 t0123456789876543210 = SuccFoo t0123456789876543210+    type family Mycompare_0123456789876543210 (a :: NatFoo) (a :: NatFoo) :: Ordering where+      Mycompare_0123456789876543210 ZeroFoo ZeroFoo = EQSym0+      Mycompare_0123456789876543210 ZeroFoo (SuccFoo _) = LTSym0+      Mycompare_0123456789876543210 (SuccFoo _) ZeroFoo = GTSym0+      Mycompare_0123456789876543210 (SuccFoo n) (SuccFoo m) = Apply (Apply MycompareSym0 m) n+    type Mycompare_0123456789876543210Sym2 (a0123456789876543210 :: NatFoo) (a0123456789876543210 :: NatFoo) =+        Mycompare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Mycompare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym1KindInference) ())+    data Mycompare_0123456789876543210Sym1 (a0123456789876543210 :: NatFoo) :: (~>) NatFoo Ordering+      where+        Mycompare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Mycompare_0123456789876543210Sym0KindInference) ())+    data Mycompare_0123456789876543210Sym0 :: (~>) NatFoo ((~>) NatFoo Ordering)+      where+        Mycompare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply Mycompare_0123456789876543210Sym0 arg) (Mycompare_0123456789876543210Sym1 arg) =>+                                                          Mycompare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Mycompare_0123456789876543210Sym0 a0123456789876543210 = Mycompare_0123456789876543210Sym1 a0123456789876543210+    instance PMyOrd NatFoo where+      type Mycompare a a = Apply (Apply Mycompare_0123456789876543210Sym0 a) a+    data SNatFoo :: NatFoo -> GHC.Types.Type+      where+        SZeroFoo :: SNatFoo ZeroFoo+        SSuccFoo :: forall (n :: NatFoo).+                    (Sing (n :: NatFoo)) -> SNatFoo (SuccFoo n)+    type instance Sing @NatFoo = SNatFoo+    instance SingKind NatFoo where+      type Demote NatFoo = NatFoo+      fromSing SZeroFoo = ZeroFoo+      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) }+    instance SMyOrd NatFoo where+      sMycompare ::+        forall (t1 :: NatFoo) (t2 :: NatFoo).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (MycompareSym0 :: TyFun NatFoo ((~>) NatFoo Ordering)+                                                   -> GHC.Types.Type) t1) t2)+      sMycompare SZeroFoo SZeroFoo = SEQ+      sMycompare SZeroFoo (SSuccFoo _) = SLT+      sMycompare (SSuccFoo _) SZeroFoo = SGT+      sMycompare (SSuccFoo (sN :: Sing n)) (SSuccFoo (sM :: Sing m))+        = (applySing+             ((applySing ((singFun2 @MycompareSym0) sMycompare)) sM))+            sN+    instance SingI ZeroFoo where+      sing = SZeroFoo+    instance SingI n => SingI (SuccFoo (n :: NatFoo)) where+      sing = SSuccFoo sing+    instance SingI (SuccFooSym0 :: (~>) NatFoo NatFoo) where+      sing = (singFun1 @SuccFooSym0) SSuccFoo
− tests/compile-and-dump/Singletons/Contains.ghc86.template 
@@ -1,50 +0,0 @@-Singletons/Contains.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| contains :: Eq a => a -> [a] -> Bool-          contains _ [] = False-          contains elt (h : t) = (elt == h) || (contains elt t) |]-  ======>-    contains :: Eq a => a -> [a] -> Bool-    contains _ [] = False-    contains elt (h : t) = ((elt == h) || (contains elt) t)-    type ContainsSym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: [a0123456789876543210]) =-        Contains a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ContainsSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ContainsSym1KindInference) ())-    data ContainsSym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) [a0123456789876543210] Bool-      where-        ContainsSym1KindInference :: forall a0123456789876543210-                                            a0123456789876543210-                                            arg. SameKind (Apply (ContainsSym1 a0123456789876543210) arg) (ContainsSym2 a0123456789876543210 arg) =>-                                     ContainsSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (ContainsSym1 a0123456789876543210) a0123456789876543210 = Contains a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ContainsSym0 where-      suppressUnusedWarnings = snd (((,) ContainsSym0KindInference) ())-    data ContainsSym0 :: forall a0123456789876543210.-                         (~>) a0123456789876543210 ((~>) [a0123456789876543210] Bool)-      where-        ContainsSym0KindInference :: forall a0123456789876543210-                                            arg. SameKind (Apply ContainsSym0 arg) (ContainsSym1 arg) =>-                                     ContainsSym0 a0123456789876543210-    type instance Apply ContainsSym0 a0123456789876543210 = ContainsSym1 a0123456789876543210-    type family Contains (a :: a) (a :: [a]) :: Bool where-      Contains _ '[] = FalseSym0-      Contains elt ( '(:) h t) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) elt) h)) (Apply (Apply ContainsSym0 elt) t)-    sContains ::-      forall a (t :: a) (t :: [a]).-      SEq a =>-      Sing t -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool)-    sContains _ SNil = SFalse-    sContains (sElt :: Sing elt) (SCons (sH :: Sing h) (sT :: Sing t))-      = (applySing-           ((applySing ((singFun2 @(||@#@$)) (%||)))-              ((applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sElt)) sH)))-          ((applySing-              ((applySing ((singFun2 @ContainsSym0) sContains)) sElt))-             sT)-    instance SEq a =>-             SingI (ContainsSym0 :: (~>) a ((~>) [a] Bool)) where-      sing = (singFun2 @ContainsSym0) sContains-    instance (SEq a, SingI d) =>-             SingI (ContainsSym1 (d :: a) :: (~>) [a] Bool) where-      sing = (singFun1 @(ContainsSym1 (d :: a))) (sContains (sing @d))
+ tests/compile-and-dump/Singletons/Contains.ghc88.template view
@@ -0,0 +1,50 @@+Singletons/Contains.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| contains :: Eq a => a -> [a] -> Bool+          contains _ [] = False+          contains elt (h : t) = (elt == h) || (contains elt t) |]+  ======>+    contains :: Eq a => a -> [a] -> Bool+    contains _ [] = False+    contains elt (h : t) = ((elt == h) || (contains elt) t)+    type ContainsSym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: [a0123456789876543210]) =+        Contains a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ContainsSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ContainsSym1KindInference) ())+    data ContainsSym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) [a0123456789876543210] Bool+      where+        ContainsSym1KindInference :: forall a0123456789876543210+                                            a0123456789876543210+                                            arg. SameKind (Apply (ContainsSym1 a0123456789876543210) arg) (ContainsSym2 a0123456789876543210 arg) =>+                                     ContainsSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (ContainsSym1 a0123456789876543210) a0123456789876543210 = Contains a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ContainsSym0 where+      suppressUnusedWarnings = snd (((,) ContainsSym0KindInference) ())+    data ContainsSym0 :: forall a0123456789876543210.+                         (~>) a0123456789876543210 ((~>) [a0123456789876543210] Bool)+      where+        ContainsSym0KindInference :: forall a0123456789876543210+                                            arg. SameKind (Apply ContainsSym0 arg) (ContainsSym1 arg) =>+                                     ContainsSym0 a0123456789876543210+    type instance Apply ContainsSym0 a0123456789876543210 = ContainsSym1 a0123456789876543210+    type family Contains (a :: a) (a :: [a]) :: Bool where+      Contains _ '[] = FalseSym0+      Contains elt ('(:) h t) = Apply (Apply (||@#@$) (Apply (Apply (==@#@$) elt) h)) (Apply (Apply ContainsSym0 elt) t)+    sContains ::+      forall a (t :: a) (t :: [a]).+      SEq a =>+      Sing t -> Sing t -> Sing (Apply (Apply ContainsSym0 t) t :: Bool)+    sContains _ SNil = SFalse+    sContains (sElt :: Sing elt) (SCons (sH :: Sing h) (sT :: Sing t))+      = (applySing+           ((applySing ((singFun2 @(||@#@$)) (%||)))+              ((applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sElt)) sH)))+          ((applySing+              ((applySing ((singFun2 @ContainsSym0) sContains)) sElt))+             sT)+    instance SEq a =>+             SingI (ContainsSym0 :: (~>) a ((~>) [a] Bool)) where+      sing = (singFun2 @ContainsSym0) sContains+    instance (SEq a, SingI d) =>+             SingI (ContainsSym1 (d :: a) :: (~>) [a] Bool) where+      sing = (singFun1 @(ContainsSym1 (d :: a))) (sContains (sing @d))
− tests/compile-and-dump/Singletons/DataValues.ghc86.template 
@@ -1,186 +0,0 @@-Singletons/DataValues.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| pr = Pair (Succ Zero) ([Zero])-          complex = Pair (Pair (Just Zero) Zero) False-          tuple = (False, Just Zero, True)-          aList = [Zero, Succ Zero, Succ (Succ Zero)]-          -          data Pair a b-            = Pair a b-            deriving Show |]-  ======>-    data Pair a b-      = Pair a b-      deriving Show-    pr = (Pair (Succ Zero)) [Zero]-    complex = (Pair ((Pair (Just Zero)) Zero)) False-    tuple = (False, Just Zero, True)-    aList = [Zero, Succ Zero, Succ (Succ Zero)]-    type PairSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =-        Pair t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (PairSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())-    data PairSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210)-      where-        PairSym1KindInference :: forall t0123456789876543210-                                        t0123456789876543210-                                        arg. SameKind (Apply (PairSym1 t0123456789876543210) arg) (PairSym2 t0123456789876543210 arg) =>-                                 PairSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (PairSym1 t0123456789876543210) t0123456789876543210 = Pair t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings PairSym0 where-      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())-    data PairSym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210))-      where-        PairSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply PairSym0 arg) (PairSym1 arg) =>-                                 PairSym0 t0123456789876543210-    type instance Apply PairSym0 t0123456789876543210 = PairSym1 t0123456789876543210-    type AListSym0 = AList-    type TupleSym0 = Tuple-    type ComplexSym0 = Complex-    type PrSym0 = Pr-    type family AList where-      AList = Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[]))-    type family Tuple where-      Tuple = Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0-    type family Complex where-      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) '[])-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a0123456789876543210 b0123456789876543210) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210-                                                                                             b0123456789876543210.-                                                                                      (~>) (Pair a0123456789876543210 b0123456789876543210) ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210-                                                     b0123456789876543210.-                                              (~>) GHC.Types.Nat ((~>) (Pair a0123456789876543210 b0123456789876543210) ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    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-    sAList-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))-          ((applySing-              ((applySing ((singFun2 @(:@#@$)) SCons))-                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((singFun1 @SuccSym0) SSucc))-                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))-                SNil))-    sTuple-      = (applySing-           ((applySing ((applySing ((singFun3 @Tuple3Sym0) STuple3)) SFalse))-              ((applySing ((singFun1 @JustSym0) SJust)) SZero)))-          STrue-    sComplex-      = (applySing-           ((applySing ((singFun2 @PairSym0) SPair))-              ((applySing-                  ((applySing ((singFun2 @PairSym0) SPair))-                     ((applySing ((singFun1 @JustSym0) SJust)) SZero)))-                 SZero)))-          SFalse-    sPr-      = (applySing-           ((applySing ((singFun2 @PairSym0) SPair))-              ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero)) SNil)-    data instance Sing :: Pair a b -> GHC.Types.Type-      where-        SPair :: forall a b (n :: a) (n :: b).-                 (Sing (n :: a)) -> (Sing (n :: b)) -> Sing (Pair n n)-    type SPair = (Sing :: Pair a b -> GHC.Types.Type)-    instance (SingKind a, SingKind b) => SingKind (Pair a b) where-      type Demote (Pair a b) = Pair (Demote a) (Demote b)-      fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b)-      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) }-    instance (SShow a, SShow b) => SShow (Pair a b) where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Pair a b) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SPair (sArg_0123456789876543210 :: Sing arg_0123456789876543210)-               (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "Pair "))))-                   ((applySing-                       ((applySing ((singFun3 @(.@#@$)) (%.)))-                          ((applySing-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                 (sFromInteger (sing :: Sing 11))))-                             sArg_0123456789876543210)))-                      ((applySing-                          ((applySing ((singFun3 @(.@#@$)) (%.)))-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))-                         ((applySing-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                (sFromInteger (sing :: Sing 11))))-                            sArg_0123456789876543210))))))-            sA_0123456789876543210-    deriving instance (Data.Singletons.ShowSing.ShowSing a,-                       Data.Singletons.ShowSing.ShowSing b) =>-                      Show (Sing (z :: Pair a b))-    instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where-      sing = (SPair sing) sing-    instance SingI (PairSym0 :: (~>) a ((~>) b (Pair a b))) where-      sing = (singFun2 @PairSym0) SPair-    instance SingI (TyCon2 Pair :: (~>) a ((~>) b (Pair a b))) where-      sing = (singFun2 @(TyCon2 Pair)) SPair-    instance SingI d =>-             SingI (PairSym1 (d :: a) :: (~>) b (Pair a b)) where-      sing = (singFun1 @(PairSym1 (d :: a))) (SPair (sing @d))-    instance SingI d =>-             SingI (TyCon1 (Pair (d :: a)) :: (~>) b (Pair a b)) where-      sing = (singFun1 @(TyCon1 (Pair (d :: a)))) (SPair (sing @d))
+ tests/compile-and-dump/Singletons/DataValues.ghc88.template view
@@ -0,0 +1,193 @@+Singletons/DataValues.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| pr = Pair (Succ Zero) ([Zero])+          complex = Pair (Pair (Just Zero) Zero) False+          tuple = (False, Just Zero, True)+          aList = [Zero, Succ Zero, Succ (Succ Zero)]+          +          data Pair a b+            = Pair a b+            deriving Show |]+  ======>+    data Pair a b+      = Pair a b+      deriving Show+    pr = (Pair (Succ Zero)) [Zero]+    complex = (Pair ((Pair (Just Zero)) Zero)) False+    tuple = (False, Just Zero, True)+    aList = [Zero, Succ Zero, Succ (Succ Zero)]+    type PairSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =+        Pair t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (PairSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())+    data PairSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210)+      where+        PairSym1KindInference :: forall t0123456789876543210+                                        t0123456789876543210+                                        arg. SameKind (Apply (PairSym1 t0123456789876543210) arg) (PairSym2 t0123456789876543210 arg) =>+                                 PairSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (PairSym1 t0123456789876543210) t0123456789876543210 = Pair t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings PairSym0 where+      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())+    data PairSym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210))+      where+        PairSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply PairSym0 arg) (PairSym1 arg) =>+                                 PairSym0 t0123456789876543210+    type instance Apply PairSym0 t0123456789876543210 = PairSym1 t0123456789876543210+    type AListSym0 = AList+    type TupleSym0 = Tuple+    type ComplexSym0 = Complex+    type PrSym0 = Pr+    type family AList where+      AList = Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[]))+    type family Tuple where+      Tuple = Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0+    type family Complex where+      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) '[])+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a0123456789876543210 b0123456789876543210) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210+                                                                                             b0123456789876543210.+                                                                                      (~>) (Pair a0123456789876543210 b0123456789876543210) ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210+                                                     b0123456789876543210.+                                              (~>) GHC.Types.Nat ((~>) (Pair a0123456789876543210 b0123456789876543210) ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    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+    sAList+      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))+          ((applySing+              ((applySing ((singFun2 @(:@#@$)) SCons))+                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((singFun1 @SuccSym0) SSucc))+                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))+                SNil))+    sTuple+      = (applySing+           ((applySing ((applySing ((singFun3 @Tuple3Sym0) STuple3)) SFalse))+              ((applySing ((singFun1 @JustSym0) SJust)) SZero)))+          STrue+    sComplex+      = (applySing+           ((applySing ((singFun2 @PairSym0) SPair))+              ((applySing+                  ((applySing ((singFun2 @PairSym0) SPair))+                     ((applySing ((singFun1 @JustSym0) SJust)) SZero)))+                 SZero)))+          SFalse+    sPr+      = (applySing+           ((applySing ((singFun2 @PairSym0) SPair))+              ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero)) SNil)+    data SPair :: forall a b. Pair a b -> GHC.Types.Type+      where+        SPair :: forall a b (n :: a) (n :: b).+                 (Sing (n :: a)) -> (Sing (n :: b)) -> SPair (Pair n n)+    type instance Sing @(Pair a b) = SPair+    instance (SingKind a, SingKind b) => SingKind (Pair a b) where+      type Demote (Pair a b) = Pair (Demote a) (Demote b)+      fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b)+      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) }+    instance (SShow a, SShow b) => SShow (Pair a b) where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Pair a b) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SPair (sArg_0123456789876543210 :: Sing arg_0123456789876543210)+               (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "Pair "))))+                   ((applySing+                       ((applySing ((singFun3 @(.@#@$)) (%.)))+                          ((applySing+                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                 (sFromInteger (sing :: Sing 11))))+                             sArg_0123456789876543210)))+                      ((applySing+                          ((applySing ((singFun3 @(.@#@$)) (%.)))+                             ((singFun1 @ShowSpaceSym0) sShowSpace)))+                         ((applySing+                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                (sFromInteger (sing :: Sing 11))))+                            sArg_0123456789876543210))))))+            sA_0123456789876543210+    instance (Data.Singletons.ShowSing.ShowSing a,+              Data.Singletons.ShowSing.ShowSing b) =>+             Show (SPair (z :: Pair a b)) where+      showsPrec+        p_0123456789876543210+        (SPair (arg_0123456789876543210 :: Sing argTy_0123456789876543210)+               (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SPair "))+               (((.) ((showsPrec 11) arg_0123456789876543210))+                  (((.) GHC.Show.showSpace)+                     ((showsPrec 11) arg_0123456789876543210)))) ::+            (Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210) =>+            ShowS+    instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where+      sing = (SPair sing) sing+    instance SingI (PairSym0 :: (~>) a ((~>) b (Pair a b))) where+      sing = (singFun2 @PairSym0) SPair+    instance SingI d =>+             SingI (PairSym1 (d :: a) :: (~>) b (Pair a b)) where+      sing = (singFun1 @(PairSym1 (d :: a))) (SPair (sing @d))
− tests/compile-and-dump/Singletons/Empty.ghc86.template 
@@ -1,10 +0,0 @@-Singletons/Empty.hs:(0,0)-(0,0): Splicing declarations-    singletons [d| data Empty |]-  ======>-    data Empty-    data instance Sing :: Empty -> GHC.Types.Type-    type SEmpty = (Sing :: Empty -> GHC.Types.Type)-    instance SingKind Empty where-      type Demote Empty = Empty-      fromSing x = case x of-      toSing x = SomeSing (case x of)
+ tests/compile-and-dump/Singletons/Empty.ghc88.template view
@@ -0,0 +1,10 @@+Singletons/Empty.hs:(0,0)-(0,0): Splicing declarations+    singletons [d| data Empty |]+  ======>+    data Empty+    data SEmpty :: Empty -> GHC.Types.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)
− tests/compile-and-dump/Singletons/EmptyShowDeriving.ghc86.template 
@@ -1,68 +0,0 @@-Singletons/EmptyShowDeriving.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Foo-          -          deriving instance Show Foo |]-  ======>-    data Foo-    deriving instance Show Foo-    type family Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 t where-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo) (a0123456789876543210 :: GHC.Types.Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo) :: (~>) GHC.Types.Symbol GHC.Types.Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow Foo where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    data instance Sing :: Foo -> GHC.Types.Type-    type SFoo = (Sing :: Foo -> GHC.Types.Type)-    instance SingKind Foo where-      type Demote Foo = Foo-      fromSing x = case x of-      toSing x = SomeSing (case x of)-    instance SShow Foo where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Foo) (t3 :: GHC.Types.Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        _-        (sV_0123456789876543210 :: Sing v_0123456789876543210)-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((case sV_0123456789876543210 of) ::-                Sing (Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 v_0123456789876543210)))-            sA_0123456789876543210-    deriving instance Show (Sing (z :: Foo))
+ tests/compile-and-dump/Singletons/EmptyShowDeriving.ghc88.template view
@@ -0,0 +1,70 @@+Singletons/EmptyShowDeriving.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Foo+          +          deriving instance Show Foo |]+  ======>+    data Foo+    deriving instance Show Foo+    type family Case_0123456789876543210 v_0123456789876543210 a_0123456789876543210 t where+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo) (a0123456789876543210 :: GHC.Types.Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo) :: (~>) GHC.Types.Symbol GHC.Types.Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow Foo where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    data SFoo :: Foo -> GHC.Types.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)+    instance SShow Foo where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Foo) (t3 :: GHC.Types.Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo ((~>) GHC.Types.Symbol GHC.Types.Symbol))+                                                             -> GHC.Types.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)))+            sA_0123456789876543210+    instance Show (SFoo (z :: Foo)) where+      showsPrec _ v_0123456789876543210 = case v_0123456789876543210 of
− tests/compile-and-dump/Singletons/EnumDeriving.ghc86.template 
@@ -1,199 +0,0 @@-Singletons/EnumDeriving.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Foo-            = Bar | Baz | Bum-            deriving Enum-          data Quux = Q1 | Q2 |]-  ======>-    data Foo-      = Bar | Baz | Bum-      deriving Enum-    data Quux = Q1 | Q2-    type BarSym0 = Bar-    type BazSym0 = Baz-    type BumSym0 = Bum-    type Q1Sym0 = Q1-    type Q2Sym0 = Q2-    type family Case_0123456789876543210 n t where-      Case_0123456789876543210 n  'True = BumSym0-      Case_0123456789876543210 n  'False = Apply ErrorSym0 "toEnum: bad argument"-    type family Case_0123456789876543210 n t where-      Case_0123456789876543210 n  'True = BazSym0-      Case_0123456789876543210 n  'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 2))-    type family Case_0123456789876543210 n t where-      Case_0123456789876543210 n  'True = BarSym0-      Case_0123456789876543210 n  'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 1))-    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: Foo where-      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0))-    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =-        ToEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat Foo-      where-        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210-    type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Types.Nat where-      FromEnum_0123456789876543210 Bar = Data.Singletons.Prelude.Num.FromInteger 0-      FromEnum_0123456789876543210 Baz = Data.Singletons.Prelude.Num.FromInteger 1-      FromEnum_0123456789876543210 Bum = Data.Singletons.Prelude.Num.FromInteger 2-    type FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Foo) =-        FromEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())-    data FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Types.Nat-      where-        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210-    instance PEnum Foo where-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a-    data instance Sing :: Foo -> GHC.Types.Type-      where-        SBar :: Sing Bar-        SBaz :: Sing Baz-        SBum :: Sing Bum-    type SFoo = (Sing :: Foo -> GHC.Types.Type)-    instance SingKind Foo where-      type Demote Foo = Foo-      fromSing SBar = Bar-      fromSing SBaz = Baz-      fromSing SBum = Bum-      toSing Bar = SomeSing SBar-      toSing Baz = SomeSing SBaz-      toSing Bum = SomeSing SBum-    data instance Sing :: Quux -> GHC.Types.Type-      where-        SQ1 :: Sing Q1-        SQ2 :: Sing Q2-    type SQuux = (Sing :: Quux -> GHC.Types.Type)-    instance SingKind Quux where-      type Demote Quux = Quux-      fromSing SQ1 = Q1-      fromSing SQ2 = Q2-      toSing Q1 = SomeSing SQ1-      toSing Q2 = SomeSing SQ2-    instance SEnum Foo where-      sToEnum ::-        forall (t :: GHC.Types.Nat).-        Sing t-        -> Sing (Apply (Data.Singletons.Prelude.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat Foo-                                                                   -> GHC.Types.Type) t)-      sFromEnum ::-        forall (t :: Foo).-        Sing t-        -> Sing (Apply (Data.Singletons.Prelude.Enum.FromEnumSym0 :: TyFun Foo GHC.Types.Nat-                                                                     -> GHC.Types.Type) t)-      sToEnum (sN :: Sing n)-        = (case-               (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))-                 (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0))-           of-             STrue -> SBar-             SFalse-               -> (case-                       (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))-                         (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 1))-                   of-                     STrue -> SBaz-                     SFalse-                       -> (case-                               (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))-                                 (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 2))-                           of-                             STrue -> SBum-                             SFalse -> sError (sing :: Sing "toEnum: bad argument")) ::-                            Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 2)))) ::-                    Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 1)))) ::-            Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0)))-      sFromEnum SBar-        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0)-      sFromEnum SBaz-        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 1)-      sFromEnum SBum-        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 2)-    instance SingI Bar where-      sing = SBar-    instance SingI Baz where-      sing = SBaz-    instance SingI Bum where-      sing = SBum-    instance SingI Q1 where-      sing = SQ1-    instance SingI Q2 where-      sing = SQ2-Singletons/EnumDeriving.hs:0:0:: Splicing declarations-    singEnumInstance ''Quux-  ======>-    type family Case_0123456789876543210 n t where-      Case_0123456789876543210 n  'True = Q2Sym0-      Case_0123456789876543210 n  'False = Apply ErrorSym0 "toEnum: bad argument"-    type family Case_0123456789876543210 n t where-      Case_0123456789876543210 n  'True = Q1Sym0-      Case_0123456789876543210 n  'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 1))-    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: Quux where-      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0))-    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =-        ToEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat Quux-      where-        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210-    type family FromEnum_0123456789876543210 (a :: Quux) :: GHC.Types.Nat where-      FromEnum_0123456789876543210  'Q1 = Data.Singletons.Prelude.Num.FromInteger 0-      FromEnum_0123456789876543210  'Q2 = Data.Singletons.Prelude.Num.FromInteger 1-    type FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Quux) =-        FromEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())-    data FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Types.Nat-      where-        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210-    instance PEnum Quux where-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a-    instance SEnum Quux where-      sToEnum ::-        forall (t :: GHC.Types.Nat).-        Sing t-        -> Sing (Apply (Data.Singletons.Prelude.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat Quux-                                                                   -> GHC.Types.Type) t)-      sFromEnum ::-        forall (t :: Quux).-        Sing t-        -> Sing (Apply (Data.Singletons.Prelude.Enum.FromEnumSym0 :: TyFun Quux GHC.Types.Nat-                                                                     -> GHC.Types.Type) t)-      sToEnum (sN :: Sing n)-        = (case-               (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))-                 (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0))-           of-             STrue -> SQ1-             SFalse-               -> (case-                       (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))-                         (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 1))-                   of-                     STrue -> SQ2-                     SFalse -> sError (sing :: Sing "toEnum: bad argument")) ::-                    Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 1)))) ::-            Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0)))-      sFromEnum SQ1-        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0)-      sFromEnum SQ2-        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 1)
+ tests/compile-and-dump/Singletons/EnumDeriving.ghc88.template view
@@ -0,0 +1,204 @@+Singletons/EnumDeriving.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Foo+            = Bar | Baz | Bum+            deriving Enum+          data Quux = Q1 | Q2 |]+  ======>+    data Foo+      = Bar | Baz | Bum+      deriving Enum+    data Quux = Q1 | Q2+    type BarSym0 = Bar+    type BazSym0 = Baz+    type BumSym0 = Bum+    type Q1Sym0 = Q1+    type Q2Sym0 = Q2+    type family Case_0123456789876543210 n t where+      Case_0123456789876543210 n 'True = BumSym0+      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+    type family Case_0123456789876543210 n t where+      Case_0123456789876543210 n 'True = BazSym0+      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 2))+    type family Case_0123456789876543210 n t where+      Case_0123456789876543210 n 'True = BarSym0+      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 1))+    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: Foo where+      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0))+    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =+        ToEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())+    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat Foo+      where+        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>+                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210+    type family FromEnum_0123456789876543210 (a :: Foo) :: GHC.Types.Nat where+      FromEnum_0123456789876543210 Bar = Data.Singletons.Prelude.Num.FromInteger 0+      FromEnum_0123456789876543210 Baz = Data.Singletons.Prelude.Num.FromInteger 1+      FromEnum_0123456789876543210 Bum = Data.Singletons.Prelude.Num.FromInteger 2+    type FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Foo) =+        FromEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())+    data FromEnum_0123456789876543210Sym0 :: (~>) Foo GHC.Types.Nat+      where+        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>+                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210+    instance PEnum Foo where+      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a+      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a+    data SFoo :: Foo -> GHC.Types.Type+      where+        SBar :: SFoo Bar+        SBaz :: SFoo Baz+        SBum :: SFoo Bum+    type instance Sing @Foo = SFoo+    instance SingKind Foo where+      type Demote Foo = Foo+      fromSing SBar = Bar+      fromSing SBaz = Baz+      fromSing SBum = Bum+      toSing Bar = SomeSing SBar+      toSing Baz = SomeSing SBaz+      toSing Bum = SomeSing SBum+    data SQuux :: Quux -> GHC.Types.Type+      where+        SQ1 :: SQuux Q1+        SQ2 :: SQuux Q2+    type instance Sing @Quux = SQuux+    instance SingKind Quux where+      type Demote Quux = Quux+      fromSing SQ1 = Q1+      fromSing SQ2 = Q2+      toSing Q1 = SomeSing SQ1+      toSing Q2 = SomeSing SQ2+    instance SEnum Foo where+      sToEnum ::+        forall (t :: GHC.Types.Nat).+        Sing t+        -> Sing (Apply (Data.Singletons.Prelude.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat Foo+                                                                   -> GHC.Types.Type) t)+      sFromEnum ::+        forall (t :: Foo).+        Sing t+        -> Sing (Apply (Data.Singletons.Prelude.Enum.FromEnumSym0 :: TyFun Foo GHC.Types.Nat+                                                                     -> GHC.Types.Type) t)+      sToEnum (sN :: Sing n)+        = (id+             @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0)))))+            (case+                 (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))+                   (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0))+             of+               STrue -> SBar+               SFalse+                 -> (id+                       @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 1)))))+                      (case+                           (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))+                             (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 1))+                       of+                         STrue -> SBaz+                         SFalse+                           -> (id+                                 @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 2)))))+                                (case+                                     (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))+                                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 2))+                                 of+                                   STrue -> SBum+                                   SFalse -> sError (sing :: Sing "toEnum: bad argument"))))+      sFromEnum SBar+        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0)+      sFromEnum SBaz+        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 1)+      sFromEnum SBum+        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 2)+    instance SingI Bar where+      sing = SBar+    instance SingI Baz where+      sing = SBaz+    instance SingI Bum where+      sing = SBum+    instance SingI Q1 where+      sing = SQ1+    instance SingI Q2 where+      sing = SQ2+Singletons/EnumDeriving.hs:0:0:: Splicing declarations+    singEnumInstance ''Quux+  ======>+    type family Case_0123456789876543210 n t where+      Case_0123456789876543210 n 'True = Q2Sym0+      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+    type family Case_0123456789876543210 n t where+      Case_0123456789876543210 n 'True = Q1Sym0+      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 1))+    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: Quux where+      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0))+    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =+        ToEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())+    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat Quux+      where+        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>+                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210+    type family FromEnum_0123456789876543210 (a :: Quux) :: GHC.Types.Nat where+      FromEnum_0123456789876543210 'Q1 = Data.Singletons.Prelude.Num.FromInteger 0+      FromEnum_0123456789876543210 'Q2 = Data.Singletons.Prelude.Num.FromInteger 1+    type FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: Quux) =+        FromEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())+    data FromEnum_0123456789876543210Sym0 :: (~>) Quux GHC.Types.Nat+      where+        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>+                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210+    instance PEnum Quux where+      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a+      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a+    instance SEnum Quux where+      sToEnum ::+        forall (t :: GHC.Types.Nat).+        Sing t+        -> Sing (Apply (Data.Singletons.Prelude.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat Quux+                                                                   -> GHC.Types.Type) t)+      sFromEnum ::+        forall (t :: Quux).+        Sing t+        -> Sing (Apply (Data.Singletons.Prelude.Enum.FromEnumSym0 :: TyFun Quux GHC.Types.Nat+                                                                     -> GHC.Types.Type) t)+      sToEnum (sN :: Sing n)+        = (id+             @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0)))))+            (case+                 (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))+                   (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0))+             of+               STrue -> SQ1+               SFalse+                 -> (id+                       @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 1)))))+                      (case+                           (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))+                             (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 1))+                       of+                         STrue -> SQ2+                         SFalse -> sError (sing :: Sing "toEnum: bad argument")))+      sFromEnum SQ1+        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0)+      sFromEnum SQ2+        = Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 1)
− tests/compile-and-dump/Singletons/EqInstances.ghc86.template 
@@ -1,21 +0,0 @@-Singletons/EqInstances.hs:0:0:: Splicing declarations-    singEqInstances [''Foo, ''Empty]-  ======>-    instance SEq Foo => SEq Foo where-      (%==) SFLeaf SFLeaf = STrue-      (%==) SFLeaf ((:%+:) _ _) = SFalse-      (%==) ((:%+:) _ _) SFLeaf = SFalse-      (%==) ((:%+:) a a) ((:%+:) b b)-        = ((%&&) (((%==) a) b)) (((%==) a) b)-    type family Equals_0123456789876543210 (a :: Foo) (b :: Foo) :: Bool where-      Equals_0123456789876543210  'FLeaf  'FLeaf = TrueSym0-      Equals_0123456789876543210 ( '(:+:) a a) ( '(:+:) b b) = (&&) ((==) a b) ((==) a b)-      Equals_0123456789876543210 (_ :: Foo) (_ :: Foo) = FalseSym0-    instance PEq Foo where-      type (==) a b = Equals_0123456789876543210 a b-    instance SEq Empty where-      (%==) _ _ = STrue-    type family Equals_0123456789876543210 (a :: Empty) (b :: Empty) :: Bool where-      Equals_0123456789876543210 (_ :: Empty) (_ :: Empty) = TrueSym0-    instance PEq Empty where-      type (==) a b = Equals_0123456789876543210 a b
+ tests/compile-and-dump/Singletons/EqInstances.ghc88.template view
@@ -0,0 +1,21 @@+Singletons/EqInstances.hs:0:0:: Splicing declarations+    singEqInstances [''Foo, ''Empty]+  ======>+    instance SEq Foo => SEq Foo where+      (%==) SFLeaf SFLeaf = STrue+      (%==) SFLeaf ((:%+:) _ _) = SFalse+      (%==) ((:%+:) _ _) SFLeaf = SFalse+      (%==) ((:%+:) a a) ((:%+:) b b)+        = ((%&&) (((%==) a) b)) (((%==) a) b)+    type family Equals_0123456789876543210 (a :: Foo) (b :: Foo) :: Bool where+      Equals_0123456789876543210 'FLeaf 'FLeaf = TrueSym0+      Equals_0123456789876543210 ('(:+:) a a) ('(:+:) b b) = (&&) ((==) a b) ((==) a b)+      Equals_0123456789876543210 (_ :: Foo) (_ :: Foo) = FalseSym0+    instance PEq Foo where+      type (==) a b = Equals_0123456789876543210 a b+    instance SEq Empty where+      (%==) _ _ = STrue+    type family Equals_0123456789876543210 (a :: Empty) (b :: Empty) :: Bool where+      Equals_0123456789876543210 (_ :: Empty) (_ :: Empty) = TrueSym0+    instance PEq Empty where+      type (==) a b = Equals_0123456789876543210 a b
− tests/compile-and-dump/Singletons/Error.ghc86.template 
@@ -1,30 +0,0 @@-Singletons/Error.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| head :: [a] -> a-          head (a : _) = a-          head [] = error "Data.Singletons.List.head: empty list" |]-  ======>-    head :: [a] -> a-    head (a : _) = a-    head [] = error "Data.Singletons.List.head: empty list"-    type HeadSym1 (a0123456789876543210 :: [a0123456789876543210]) =-        Head a0123456789876543210-    instance SuppressUnusedWarnings HeadSym0 where-      suppressUnusedWarnings = snd (((,) HeadSym0KindInference) ())-    data HeadSym0 :: forall a0123456789876543210.-                     (~>) [a0123456789876543210] a0123456789876543210-      where-        HeadSym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply HeadSym0 arg) (HeadSym1 arg) =>-                                 HeadSym0 a0123456789876543210-    type instance Apply HeadSym0 a0123456789876543210 = Head a0123456789876543210-    type family Head (a :: [a]) :: a where-      Head ( '(:) a _) = a-      Head '[] = Apply ErrorSym0 "Data.Singletons.List.head: empty list"-    sHead ::-      forall a (t :: [a]). Sing t -> Sing (Apply HeadSym0 t :: a)-    sHead (SCons (sA :: Sing a) _) = sA-    sHead SNil-      = sError (sing :: Sing "Data.Singletons.List.head: empty list")-    instance SingI (HeadSym0 :: (~>) [a] a) where-      sing = (singFun1 @HeadSym0) sHead
+ tests/compile-and-dump/Singletons/Error.ghc88.template view
@@ -0,0 +1,30 @@+Singletons/Error.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| head :: [a] -> a+          head (a : _) = a+          head [] = error "Data.Singletons.List.head: empty list" |]+  ======>+    head :: [a] -> a+    head (a : _) = a+    head [] = error "Data.Singletons.List.head: empty list"+    type HeadSym1 (a0123456789876543210 :: [a0123456789876543210]) =+        Head a0123456789876543210+    instance SuppressUnusedWarnings HeadSym0 where+      suppressUnusedWarnings = snd (((,) HeadSym0KindInference) ())+    data HeadSym0 :: forall a0123456789876543210.+                     (~>) [a0123456789876543210] a0123456789876543210+      where+        HeadSym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply HeadSym0 arg) (HeadSym1 arg) =>+                                 HeadSym0 a0123456789876543210+    type instance Apply HeadSym0 a0123456789876543210 = Head a0123456789876543210+    type family Head (a :: [a]) :: a where+      Head ('(:) a _) = a+      Head '[] = Apply ErrorSym0 "Data.Singletons.List.head: empty list"+    sHead ::+      forall a (t :: [a]). Sing t -> Sing (Apply HeadSym0 t :: a)+    sHead (SCons (sA :: Sing a) _) = sA+    sHead SNil+      = sError (sing :: Sing "Data.Singletons.List.head: empty list")+    instance SingI (HeadSym0 :: (~>) [a] a) where+      sing = (singFun1 @HeadSym0) sHead
− tests/compile-and-dump/Singletons/Fixity.ghc86.template 
@@ -1,86 +0,0 @@-Singletons/Fixity.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| infix 4 ====-          infix 4 <=>-          -          (====) :: a -> a -> a-          a ==== _ = a-          -          class MyOrd a where-            (<=>) :: a -> a -> Ordering-            infix 4 <=> |]-  ======>-    class MyOrd a where-      (<=>) :: a -> a -> Ordering-    infix 4 <=>-    (====) :: a -> a -> a-    (====) a _ = a-    infix 4 ====-    type (====@#@$$$) (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: a0123456789876543210) =-        (====) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((====@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:====@#@$$###)) ())-    data (====@#@$$) (a0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 a0123456789876543210-      where-        (:====@#@$$###) :: forall a0123456789876543210-                                  a0123456789876543210-                                  arg. SameKind (Apply ((====@#@$$) a0123456789876543210) arg) ((====@#@$$$) a0123456789876543210 arg) =>-                           (====@#@$$) a0123456789876543210 a0123456789876543210-    type instance Apply ((====@#@$$) a0123456789876543210) a0123456789876543210 = (====) a0123456789876543210 a0123456789876543210-    infix 4 ====@#@$$-    instance SuppressUnusedWarnings (====@#@$) where-      suppressUnusedWarnings = snd (((,) (:====@#@$###)) ())-    data (====@#@$) :: forall a0123456789876543210.-                       (~>) a0123456789876543210 ((~>) a0123456789876543210 a0123456789876543210)-      where-        (:====@#@$###) :: forall a0123456789876543210-                                 arg. SameKind (Apply (====@#@$) arg) ((====@#@$$) arg) =>-                          (====@#@$) a0123456789876543210-    type instance Apply (====@#@$) a0123456789876543210 = (====@#@$$) a0123456789876543210-    infix 4 ====@#@$-    type family (====) (a :: a) (a :: a) :: a where-      (====) a _ = a-    type (<=>@#@$$$) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =-        (<=>) arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings ((<=>@#@$$) arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:<=>@#@$$###)) ())-    data (<=>@#@$$) (arg0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 Ordering-      where-        (:<=>@#@$$###) :: forall arg0123456789876543210-                                 arg0123456789876543210-                                 arg. SameKind (Apply ((<=>@#@$$) arg0123456789876543210) arg) ((<=>@#@$$$) arg0123456789876543210 arg) =>-                          (<=>@#@$$) arg0123456789876543210 arg0123456789876543210-    type instance Apply ((<=>@#@$$) arg0123456789876543210) arg0123456789876543210 = (<=>) arg0123456789876543210 arg0123456789876543210-    infix 4 <=>@#@$$-    instance SuppressUnusedWarnings (<=>@#@$) where-      suppressUnusedWarnings = snd (((,) (:<=>@#@$###)) ())-    data (<=>@#@$) :: forall a0123456789876543210.-                      (~>) a0123456789876543210 ((~>) a0123456789876543210 Ordering)-      where-        (:<=>@#@$###) :: forall arg0123456789876543210-                                arg. SameKind (Apply (<=>@#@$) arg) ((<=>@#@$$) arg) =>-                         (<=>@#@$) arg0123456789876543210-    type instance Apply (<=>@#@$) arg0123456789876543210 = (<=>@#@$$) arg0123456789876543210-    infix 4 <=>@#@$-    class PMyOrd (a :: GHC.Types.Type) where-      type (<=>) (arg :: a) (arg :: a) :: Ordering-    infix 4 %====-    infix 4 %<=>-    (%====) ::-      forall a (t :: a) (t :: a).-      Sing t -> Sing t -> Sing (Apply (Apply (====@#@$) t) t :: a)-    (%====) (sA :: Sing a) _ = sA-    instance SingI ((====@#@$) :: (~>) a ((~>) a a)) where-      sing = (singFun2 @(====@#@$)) (%====)-    instance SingI d => SingI ((====@#@$$) (d :: a) :: (~>) a a) where-      sing = (singFun1 @((====@#@$$) (d :: a))) ((%====) (sing @d))-    class SMyOrd a where-      (%<=>) ::-        forall (t :: a) (t :: a).-        Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering)-    instance SMyOrd a =>-             SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where-      sing = (singFun2 @(<=>@#@$)) (%<=>)-    instance (SMyOrd a, SingI d) =>-             SingI ((<=>@#@$$) (d :: a) :: (~>) a Ordering) where-      sing = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) (sing @d))
+ tests/compile-and-dump/Singletons/Fixity.ghc88.template view
@@ -0,0 +1,86 @@+Singletons/Fixity.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| infix 4 ====+          infix 4 <=>+          +          (====) :: a -> a -> a+          a ==== _ = a+          +          class MyOrd a where+            (<=>) :: a -> a -> Ordering+            infix 4 <=> |]+  ======>+    class MyOrd a where+      (<=>) :: a -> a -> Ordering+    infix 4 <=>+    (====) :: a -> a -> a+    (====) a _ = a+    infix 4 ====+    type (====@#@$$$) (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: a0123456789876543210) =+        (====) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((====@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:====@#@$$###)) ())+    data (====@#@$$) (a0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 a0123456789876543210+      where+        (:====@#@$$###) :: forall a0123456789876543210+                                  a0123456789876543210+                                  arg. SameKind (Apply ((====@#@$$) a0123456789876543210) arg) ((====@#@$$$) a0123456789876543210 arg) =>+                           (====@#@$$) a0123456789876543210 a0123456789876543210+    type instance Apply ((====@#@$$) a0123456789876543210) a0123456789876543210 = (====) a0123456789876543210 a0123456789876543210+    infix 4 ====@#@$$+    instance SuppressUnusedWarnings (====@#@$) where+      suppressUnusedWarnings = snd (((,) (:====@#@$###)) ())+    data (====@#@$) :: forall a0123456789876543210.+                       (~>) a0123456789876543210 ((~>) a0123456789876543210 a0123456789876543210)+      where+        (:====@#@$###) :: forall a0123456789876543210+                                 arg. SameKind (Apply (====@#@$) arg) ((====@#@$$) arg) =>+                          (====@#@$) a0123456789876543210+    type instance Apply (====@#@$) a0123456789876543210 = (====@#@$$) a0123456789876543210+    infix 4 ====@#@$+    type family (====) (a :: a) (a :: a) :: a where+      (====) a _ = a+    type (<=>@#@$$$) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =+        (<=>) arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings ((<=>@#@$$) arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:<=>@#@$$###)) ())+    data (<=>@#@$$) (arg0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 Ordering+      where+        (:<=>@#@$$###) :: forall arg0123456789876543210+                                 arg0123456789876543210+                                 arg. SameKind (Apply ((<=>@#@$$) arg0123456789876543210) arg) ((<=>@#@$$$) arg0123456789876543210 arg) =>+                          (<=>@#@$$) arg0123456789876543210 arg0123456789876543210+    type instance Apply ((<=>@#@$$) arg0123456789876543210) arg0123456789876543210 = (<=>) arg0123456789876543210 arg0123456789876543210+    infix 4 <=>@#@$$+    instance SuppressUnusedWarnings (<=>@#@$) where+      suppressUnusedWarnings = snd (((,) (:<=>@#@$###)) ())+    data (<=>@#@$) :: forall a0123456789876543210.+                      (~>) a0123456789876543210 ((~>) a0123456789876543210 Ordering)+      where+        (:<=>@#@$###) :: forall arg0123456789876543210+                                arg. SameKind (Apply (<=>@#@$) arg) ((<=>@#@$$) arg) =>+                         (<=>@#@$) arg0123456789876543210+    type instance Apply (<=>@#@$) arg0123456789876543210 = (<=>@#@$$) arg0123456789876543210+    infix 4 <=>@#@$+    class PMyOrd (a :: GHC.Types.Type) where+      type (<=>) (arg :: a) (arg :: a) :: Ordering+    infix 4 %====+    infix 4 %<=>+    (%====) ::+      forall a (t :: a) (t :: a).+      Sing t -> Sing t -> Sing (Apply (Apply (====@#@$) t) t :: a)+    (%====) (sA :: Sing a) _ = sA+    instance SingI ((====@#@$) :: (~>) a ((~>) a a)) where+      sing = (singFun2 @(====@#@$)) (%====)+    instance SingI d => SingI ((====@#@$$) (d :: a) :: (~>) a a) where+      sing = (singFun1 @((====@#@$$) (d :: a))) ((%====) (sing @d))+    class SMyOrd a where+      (%<=>) ::+        forall (t :: a) (t :: a).+        Sing t -> Sing t -> Sing (Apply (Apply (<=>@#@$) t) t :: Ordering)+    instance SMyOrd a =>+             SingI ((<=>@#@$) :: (~>) a ((~>) a Ordering)) where+      sing = (singFun2 @(<=>@#@$)) (%<=>)+    instance (SMyOrd a, SingI d) =>+             SingI ((<=>@#@$$) (d :: a) :: (~>) a Ordering) where+      sing = (singFun1 @((<=>@#@$$) (d :: a))) ((%<=>) (sing @d))
− tests/compile-and-dump/Singletons/FunDeps.ghc86.template 
@@ -1,96 +0,0 @@-Singletons/FunDeps.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| t1 = meth True-          -          class FD a b | a -> b where-            meth :: a -> a-            l2r :: a -> b-          -          instance FD Bool Nat where-            meth = not-            l2r False = 0-            l2r True = 1 |]-  ======>-    class FD a b | a -> b where-      meth :: a -> a-      l2r :: a -> b-    instance FD Bool Nat where-      meth = not-      l2r False = 0-      l2r True = 1-    t1 = meth True-    type T1Sym0 = T1-    type family T1 where-      T1 = Apply MethSym0 TrueSym0-    type MethSym1 (arg0123456789876543210 :: a0123456789876543210) =-        Meth arg0123456789876543210-    instance SuppressUnusedWarnings MethSym0 where-      suppressUnusedWarnings = snd (((,) MethSym0KindInference) ())-    data MethSym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 a0123456789876543210-      where-        MethSym0KindInference :: forall arg0123456789876543210-                                        arg. SameKind (Apply MethSym0 arg) (MethSym1 arg) =>-                                 MethSym0 arg0123456789876543210-    type instance Apply MethSym0 arg0123456789876543210 = Meth arg0123456789876543210-    type L2rSym1 (arg0123456789876543210 :: a0123456789876543210) =-        L2r arg0123456789876543210-    instance SuppressUnusedWarnings L2rSym0 where-      suppressUnusedWarnings = snd (((,) L2rSym0KindInference) ())-    data L2rSym0 :: forall a0123456789876543210 b0123456789876543210.-                    (~>) a0123456789876543210 b0123456789876543210-      where-        L2rSym0KindInference :: forall arg0123456789876543210-                                       arg. SameKind (Apply L2rSym0 arg) (L2rSym1 arg) =>-                                L2rSym0 arg0123456789876543210-    type instance Apply L2rSym0 arg0123456789876543210 = L2r arg0123456789876543210-    class PFD (a :: GHC.Types.Type) (b :: GHC.Types.Type) | a -> b where-      type Meth (arg :: a) :: a-      type L2r (arg :: a) :: b-    type family Meth_0123456789876543210 (a :: Bool) :: Bool where-      Meth_0123456789876543210 a_0123456789876543210 = Apply NotSym0 a_0123456789876543210-    type Meth_0123456789876543210Sym1 (a0123456789876543210 :: Bool) =-        Meth_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Meth_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Meth_0123456789876543210Sym0KindInference) ())-    data Meth_0123456789876543210Sym0 :: (~>) Bool Bool-      where-        Meth_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                            arg. SameKind (Apply Meth_0123456789876543210Sym0 arg) (Meth_0123456789876543210Sym1 arg) =>-                                                     Meth_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Meth_0123456789876543210Sym0 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210-    type family L2r_0123456789876543210 (a :: Bool) :: Nat where-      L2r_0123456789876543210  'False = FromInteger 0-      L2r_0123456789876543210  'True = FromInteger 1-    type L2r_0123456789876543210Sym1 (a0123456789876543210 :: Bool) =-        L2r_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings L2r_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) L2r_0123456789876543210Sym0KindInference) ())-    data L2r_0123456789876543210Sym0 :: (~>) Bool Nat-      where-        L2r_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                           arg. SameKind (Apply L2r_0123456789876543210Sym0 arg) (L2r_0123456789876543210Sym1 arg) =>-                                                    L2r_0123456789876543210Sym0 a0123456789876543210-    type instance Apply L2r_0123456789876543210Sym0 a0123456789876543210 = L2r_0123456789876543210 a0123456789876543210-    instance PFD Bool Nat where-      type Meth a = Apply Meth_0123456789876543210Sym0 a-      type L2r a = Apply L2r_0123456789876543210Sym0 a-    sT1 :: Sing T1Sym0-    sT1 = (applySing ((singFun1 @MethSym0) sMeth)) STrue-    class SFD a b | a -> b where-      sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a)-      sL2r :: forall (t :: a). Sing t -> Sing (Apply L2rSym0 t :: b)-    instance SFD Bool Nat where-      sMeth ::-        forall (t :: Bool). Sing t -> Sing (Apply MethSym0 t :: Bool)-      sL2r :: forall (t :: Bool). Sing t -> Sing (Apply L2rSym0 t :: Nat)-      sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing ((singFun1 @NotSym0) sNot)) sA_0123456789876543210-      sL2r SFalse = sFromInteger (sing :: Sing 0)-      sL2r STrue = sFromInteger (sing :: Sing 1)-    instance SFD a b => SingI (MethSym0 :: (~>) a a) where-      sing = (singFun1 @MethSym0) sMeth-    instance SFD a b => SingI (L2rSym0 :: (~>) a b) where-      sing = (singFun1 @L2rSym0) sL2r
+ tests/compile-and-dump/Singletons/FunDeps.ghc88.template view
@@ -0,0 +1,96 @@+Singletons/FunDeps.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| t1 = meth True+          +          class FD a b | a -> b where+            meth :: a -> a+            l2r :: a -> b+          +          instance FD Bool Nat where+            meth = not+            l2r False = 0+            l2r True = 1 |]+  ======>+    class FD a b | a -> b where+      meth :: a -> a+      l2r :: a -> b+    instance FD Bool Nat where+      meth = not+      l2r False = 0+      l2r True = 1+    t1 = meth True+    type T1Sym0 = T1+    type family T1 where+      T1 = Apply MethSym0 TrueSym0+    type MethSym1 (arg0123456789876543210 :: a0123456789876543210) =+        Meth arg0123456789876543210+    instance SuppressUnusedWarnings MethSym0 where+      suppressUnusedWarnings = snd (((,) MethSym0KindInference) ())+    data MethSym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 a0123456789876543210+      where+        MethSym0KindInference :: forall arg0123456789876543210+                                        arg. SameKind (Apply MethSym0 arg) (MethSym1 arg) =>+                                 MethSym0 arg0123456789876543210+    type instance Apply MethSym0 arg0123456789876543210 = Meth arg0123456789876543210+    type L2rSym1 (arg0123456789876543210 :: a0123456789876543210) =+        L2r arg0123456789876543210+    instance SuppressUnusedWarnings L2rSym0 where+      suppressUnusedWarnings = snd (((,) L2rSym0KindInference) ())+    data L2rSym0 :: forall a0123456789876543210 b0123456789876543210.+                    (~>) a0123456789876543210 b0123456789876543210+      where+        L2rSym0KindInference :: forall arg0123456789876543210+                                       arg. SameKind (Apply L2rSym0 arg) (L2rSym1 arg) =>+                                L2rSym0 arg0123456789876543210+    type instance Apply L2rSym0 arg0123456789876543210 = L2r arg0123456789876543210+    class PFD (a :: GHC.Types.Type) (b :: GHC.Types.Type) | a -> b where+      type Meth (arg :: a) :: a+      type L2r (arg :: a) :: b+    type family Meth_0123456789876543210 (a :: Bool) :: Bool where+      Meth_0123456789876543210 a_0123456789876543210 = Apply NotSym0 a_0123456789876543210+    type Meth_0123456789876543210Sym1 (a0123456789876543210 :: Bool) =+        Meth_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Meth_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Meth_0123456789876543210Sym0KindInference) ())+    data Meth_0123456789876543210Sym0 :: (~>) Bool Bool+      where+        Meth_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                            arg. SameKind (Apply Meth_0123456789876543210Sym0 arg) (Meth_0123456789876543210Sym1 arg) =>+                                                     Meth_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Meth_0123456789876543210Sym0 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210+    type family L2r_0123456789876543210 (a :: Bool) :: Nat where+      L2r_0123456789876543210 'False = FromInteger 0+      L2r_0123456789876543210 'True = FromInteger 1+    type L2r_0123456789876543210Sym1 (a0123456789876543210 :: Bool) =+        L2r_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings L2r_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) L2r_0123456789876543210Sym0KindInference) ())+    data L2r_0123456789876543210Sym0 :: (~>) Bool Nat+      where+        L2r_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                           arg. SameKind (Apply L2r_0123456789876543210Sym0 arg) (L2r_0123456789876543210Sym1 arg) =>+                                                    L2r_0123456789876543210Sym0 a0123456789876543210+    type instance Apply L2r_0123456789876543210Sym0 a0123456789876543210 = L2r_0123456789876543210 a0123456789876543210+    instance PFD Bool Nat where+      type Meth a = Apply Meth_0123456789876543210Sym0 a+      type L2r a = Apply L2r_0123456789876543210Sym0 a+    sT1 :: Sing T1Sym0+    sT1 = (applySing ((singFun1 @MethSym0) sMeth)) STrue+    class SFD a b | a -> b where+      sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a)+      sL2r :: forall (t :: a). Sing t -> Sing (Apply L2rSym0 t :: b)+    instance SFD Bool Nat where+      sMeth ::+        forall (t :: Bool). Sing t -> Sing (Apply MethSym0 t :: Bool)+      sL2r :: forall (t :: Bool). Sing t -> Sing (Apply L2rSym0 t :: Nat)+      sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing ((singFun1 @NotSym0) sNot)) sA_0123456789876543210+      sL2r SFalse = sFromInteger (sing :: Sing 0)+      sL2r STrue = sFromInteger (sing :: Sing 1)+    instance SFD a b => SingI (MethSym0 :: (~>) a a) where+      sing = (singFun1 @MethSym0) sMeth+    instance SFD a b => SingI (L2rSym0 :: (~>) a b) where+      sing = (singFun1 @L2rSym0) sL2r
− tests/compile-and-dump/Singletons/FunctorLikeDeriving.ghc86.template 
@@ -1,1646 +0,0 @@-Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data T x a-            = MkT1 x a (Maybe a) (Maybe (Maybe a)) | MkT2 (Maybe x)-            deriving (Functor, Foldable, Traversable)-          data Empty (a :: Type) deriving (Functor, Foldable, Traversable) |]-  ======>-    data T x a-      = MkT1 x a (Maybe a) (Maybe (Maybe a)) | MkT2 (Maybe x)-      deriving (Functor, Foldable, Traversable)-    data Empty (a :: Type) deriving (Functor, Foldable, Traversable)-    type MkT1Sym4 (t0123456789876543210 :: x0123456789876543210) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: Maybe a0123456789876543210) (t0123456789876543210 :: Maybe (Maybe a0123456789876543210)) =-        MkT1 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkT1Sym3KindInference) ())-    data MkT1Sym3 (t0123456789876543210 :: x0123456789876543210) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: Maybe a0123456789876543210) :: (~>) (Maybe (Maybe a0123456789876543210)) (T x0123456789876543210 a0123456789876543210)-      where-        MkT1Sym3KindInference :: forall t0123456789876543210-                                        t0123456789876543210-                                        t0123456789876543210-                                        t0123456789876543210-                                        arg. SameKind (Apply (MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (MkT1Sym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                                 MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = MkT1 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkT1Sym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkT1Sym2KindInference) ())-    data MkT1Sym2 (t0123456789876543210 :: x0123456789876543210) (t0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) ((~>) (Maybe (Maybe a0123456789876543210)) (T x0123456789876543210 a0123456789876543210))-      where-        MkT1Sym2KindInference :: forall t0123456789876543210-                                        t0123456789876543210-                                        t0123456789876543210-                                        arg. SameKind (Apply (MkT1Sym2 t0123456789876543210 t0123456789876543210) arg) (MkT1Sym3 t0123456789876543210 t0123456789876543210 arg) =>-                                 MkT1Sym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (MkT1Sym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkT1Sym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkT1Sym1KindInference) ())-    data MkT1Sym1 (t0123456789876543210 :: x0123456789876543210) :: forall a0123456789876543210.-                                                                    (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) ((~>) (Maybe (Maybe a0123456789876543210)) (T x0123456789876543210 a0123456789876543210)))-      where-        MkT1Sym1KindInference :: forall t0123456789876543210-                                        t0123456789876543210-                                        arg. SameKind (Apply (MkT1Sym1 t0123456789876543210) arg) (MkT1Sym2 t0123456789876543210 arg) =>-                                 MkT1Sym1 t0123456789876543210 t0123456789876543210-    type instance Apply (MkT1Sym1 t0123456789876543210) t0123456789876543210 = MkT1Sym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings MkT1Sym0 where-      suppressUnusedWarnings = snd (((,) MkT1Sym0KindInference) ())-    data MkT1Sym0 :: forall a0123456789876543210 x0123456789876543210.-                     (~>) x0123456789876543210 ((~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) ((~>) (Maybe (Maybe a0123456789876543210)) (T x0123456789876543210 a0123456789876543210))))-      where-        MkT1Sym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply MkT1Sym0 arg) (MkT1Sym1 arg) =>-                                 MkT1Sym0 t0123456789876543210-    type instance Apply MkT1Sym0 t0123456789876543210 = MkT1Sym1 t0123456789876543210-    type MkT2Sym1 (t0123456789876543210 :: Maybe x0123456789876543210) =-        MkT2 t0123456789876543210-    instance SuppressUnusedWarnings MkT2Sym0 where-      suppressUnusedWarnings = snd (((,) MkT2Sym0KindInference) ())-    data MkT2Sym0 :: forall a0123456789876543210 x0123456789876543210.-                     (~>) (Maybe x0123456789876543210) (T x0123456789876543210 a0123456789876543210)-      where-        MkT2Sym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply MkT2Sym0 arg) (MkT2Sym1 arg) =>-                                 MkT2Sym0 t0123456789876543210-    type instance Apply MkT2Sym0 t0123456789876543210 = MkT2 t0123456789876543210-    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t where-      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210-    type Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. 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 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 t where-      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210-    type Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family Fmap_0123456789876543210 (a :: (~>) a b) (a :: T x a) :: T x b where-      Fmap_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (Apply (Apply MkT1Sym0 (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply _f_0123456789876543210 a_0123456789876543210)) (Apply (Apply FmapSym0 _f_0123456789876543210) a_0123456789876543210)) (Apply (Apply FmapSym0 (Apply FmapSym0 _f_0123456789876543210)) a_0123456789876543210)-      Fmap_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply MkT2Sym0 (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210)-    type Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a0123456789876543210) =-        Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Fmap_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Fmap_0123456789876543210Sym1KindInference) ())-    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: forall x0123456789876543210.-                                                                                                                  (~>) (T x0123456789876543210 a0123456789876543210) (T x0123456789876543210 b0123456789876543210)-      where-        Fmap_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                            a0123456789876543210-                                                            arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Fmap_0123456789876543210Sym0KindInference) ())-    data Fmap_0123456789876543210Sym0 :: forall a0123456789876543210-                                                b0123456789876543210-                                                x0123456789876543210.-                                         (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) (T x0123456789876543210 a0123456789876543210) (T x0123456789876543210 b0123456789876543210))-      where-        Fmap_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                            arg. SameKind (Apply Fmap_0123456789876543210Sym0 arg) (Fmap_0123456789876543210Sym1 arg) =>-                                                     Fmap_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Fmap_0123456789876543210Sym0 a0123456789876543210 = Fmap_0123456789876543210Sym1 a0123456789876543210-    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t where-      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210-    type Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())-    data Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym5KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. 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 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _z_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210-    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t where-      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = _z_0123456789876543210-    type Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())-    data Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym5KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. 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 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _z_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210-    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 t where-      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210-    type Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _z_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210-    type family TFHelper_0123456789876543210 (a :: a) (a :: T x b) :: T x a where-      TFHelper_0123456789876543210 _z_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (Apply (Apply MkT1Sym0 (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply (Apply (<$@#@$) _z_0123456789876543210) a_0123456789876543210)) (Apply (Apply FmapSym0 (Apply (<$@#@$) _z_0123456789876543210)) a_0123456789876543210)-      TFHelper_0123456789876543210 _z_0123456789876543210 (MkT2 a_0123456789876543210) = Apply MkT2Sym0 (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210)-    type TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: T x0123456789876543210 b0123456789876543210) =-        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210-                                                                                                   x0123456789876543210.-                                                                                            (~>) (T x0123456789876543210 b0123456789876543210) (T x0123456789876543210 a0123456789876543210)-      where-        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())-    data TFHelper_0123456789876543210Sym0 :: forall a0123456789876543210-                                                    b0123456789876543210-                                                    x0123456789876543210.-                                             (~>) a0123456789876543210 ((~>) (T x0123456789876543210 b0123456789876543210) (T x0123456789876543210 a0123456789876543210))-      where-        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210-    instance PFunctor (T x) where-      type Fmap a a = Apply (Apply Fmap_0123456789876543210Sym0 a) a-      type (<$) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a-    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t where-      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = MemptySym0-    type Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. 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 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 t where-      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = MemptySym0-    type Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family FoldMap_0123456789876543210 (a :: (~>) a m) (a :: T x a) :: m where-      FoldMap_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply MappendSym0 (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply (Apply MappendSym0 (Apply _f_0123456789876543210 a_0123456789876543210)) (Apply (Apply MappendSym0 (Apply (Apply FoldMapSym0 _f_0123456789876543210) a_0123456789876543210)) (Apply (Apply FoldMapSym0 (Apply FoldMapSym0 _f_0123456789876543210)) a_0123456789876543210)))-      FoldMap_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210-    type FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a0123456789876543210) =-        FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (FoldMap_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) FoldMap_0123456789876543210Sym1KindInference) ())-    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) :: forall x0123456789876543210.-                                                                                                                     (~>) (T x0123456789876543210 a0123456789876543210) m0123456789876543210-      where-        FoldMap_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FoldMap_0123456789876543210Sym0KindInference) ())-    data FoldMap_0123456789876543210Sym0 :: forall a0123456789876543210-                                                   m0123456789876543210-                                                   x0123456789876543210.-                                            (~>) ((~>) a0123456789876543210 m0123456789876543210) ((~>) (T x0123456789876543210 a0123456789876543210) m0123456789876543210)-      where-        FoldMap_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply FoldMap_0123456789876543210Sym0 arg) (FoldMap_0123456789876543210Sym1 arg) =>-                                                        FoldMap_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FoldMap_0123456789876543210Sym0 a0123456789876543210 = FoldMap_0123456789876543210Sym1 a0123456789876543210-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t where-      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = n2_0123456789876543210-    type Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())-    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym7KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())-    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym6KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. 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 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t 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-    type Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())-    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym7KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())-    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym6KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. 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 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t where-      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = Apply (Apply (Apply FoldrSym0 _f_0123456789876543210) n2_0123456789876543210) n1_0123456789876543210-    type Lambda_0123456789876543210Sym10 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym9 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym9KindInference) ())-    data Lambda_0123456789876543210Sym9 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym9KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              n1_01234567898765432100123456789876543210-                                                              n2_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym9 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym10 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym9 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym9 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym8 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym8KindInference) ())-    data Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym8KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              n1_01234567898765432100123456789876543210-                                                              n2_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym9 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym8 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym9 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())-    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym7KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              n1_01234567898765432100123456789876543210-                                                              n2_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym8 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())-    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym6KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              n1_01234567898765432100123456789876543210-                                                              n2_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              n1_01234567898765432100123456789876543210-                                                              n2_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              n1_01234567898765432100123456789876543210-                                                              n2_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym4 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              n1_01234567898765432100123456789876543210-                                                              n2_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              n1_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) n1_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t 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 _f_0123456789876543210) _z_0123456789876543210) n1_0123456789876543210) n2_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) n2_0123456789876543210) n1_0123456789876543210-    type Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())-    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym7KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())-    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym6KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. 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 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())-    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 t t where-      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = n2_0123456789876543210-    type Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 t0123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym4 t0123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. 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 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210-                                                              _z_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210-    type family Foldr_0123456789876543210 (a :: (~>) a ((~>) b b)) (a :: b) (a :: T x a) :: b where-      Foldr_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) (Apply (Apply _f_0123456789876543210 a_0123456789876543210) (Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) (Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) _z_0123456789876543210)))-      Foldr_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) _z_0123456789876543210-    type Foldr_0123456789876543210Sym3 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a0123456789876543210) =-        Foldr_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Foldr_0123456789876543210Sym2KindInference) ())-    data Foldr_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: b0123456789876543210) :: forall x0123456789876543210.-                                                                                                                                                                                              (~>) (T x0123456789876543210 a0123456789876543210) b0123456789876543210-      where-        Foldr_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                             a0123456789876543210-                                                             a0123456789876543210-                                                             arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Foldr_0123456789876543210Sym1KindInference) ())-    data Foldr_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) :: forall x0123456789876543210.-                                                                                                                                               (~>) b0123456789876543210 ((~>) (T x0123456789876543210 a0123456789876543210) b0123456789876543210)-      where-        Foldr_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                             a0123456789876543210-                                                             arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Foldr_0123456789876543210Sym0KindInference) ())-    data Foldr_0123456789876543210Sym0 :: forall a0123456789876543210-                                                 b0123456789876543210-                                                 x0123456789876543210.-                                          (~>) ((~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) ((~>) b0123456789876543210 ((~>) (T x0123456789876543210 a0123456789876543210) b0123456789876543210))-      where-        Foldr_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                             arg. SameKind (Apply Foldr_0123456789876543210Sym0 arg) (Foldr_0123456789876543210Sym1 arg) =>-                                                      Foldr_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Foldr_0123456789876543210Sym0 a0123456789876543210 = Foldr_0123456789876543210Sym1 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 family Traverse_0123456789876543210 (a :: (~>) a (f b)) (a :: T x a) :: f (T x b) where-      Traverse_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (<*>@#@$) (Apply (Apply (<*>@#@$) (Apply (Apply (Apply LiftA2Sym0 MkT1Sym0) (Apply PureSym0 a_0123456789876543210)) (Apply _f_0123456789876543210 a_0123456789876543210))) (Apply (Apply TraverseSym0 _f_0123456789876543210) a_0123456789876543210))) (Apply (Apply TraverseSym0 (Apply TraverseSym0 _f_0123456789876543210)) a_0123456789876543210)-      Traverse_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply FmapSym0 MkT2Sym0) (Apply PureSym0 a_0123456789876543210)-    type Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: T x0123456789876543210 a0123456789876543210) =-        Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Traverse_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Traverse_0123456789876543210Sym1KindInference) ())-    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) :: forall x0123456789876543210.-                                                                                                                                             (~>) (T x0123456789876543210 a0123456789876543210) (f0123456789876543210 (T x0123456789876543210 b0123456789876543210))-      where-        Traverse_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Traverse_0123456789876543210Sym0KindInference) ())-    data Traverse_0123456789876543210Sym0 :: forall a0123456789876543210-                                                    b0123456789876543210-                                                    f0123456789876543210-                                                    x0123456789876543210.-                                             (~>) ((~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) ((~>) (T x0123456789876543210 a0123456789876543210) (f0123456789876543210 (T x0123456789876543210 b0123456789876543210)))-      where-        Traverse_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply Traverse_0123456789876543210Sym0 arg) (Traverse_0123456789876543210Sym1 arg) =>-                                                         Traverse_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Traverse_0123456789876543210Sym0 a0123456789876543210 = Traverse_0123456789876543210Sym1 a0123456789876543210-    instance PTraversable (T x) where-      type Traverse a a = Apply (Apply Traverse_0123456789876543210Sym0 a) a-    type family Case_0123456789876543210 v_0123456789876543210 t where-    type family Fmap_0123456789876543210 (a :: (~>) a b) (a :: Empty a) :: Empty b where-      Fmap_0123456789876543210 _ v_0123456789876543210 = Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210-    type Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Empty a0123456789876543210) =-        Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Fmap_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Fmap_0123456789876543210Sym1KindInference) ())-    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) (Empty a0123456789876543210) (Empty b0123456789876543210)-      where-        Fmap_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                            a0123456789876543210-                                                            arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Fmap_0123456789876543210Sym0KindInference) ())-    data Fmap_0123456789876543210Sym0 :: forall a0123456789876543210-                                                b0123456789876543210.-                                         (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) (Empty a0123456789876543210) (Empty b0123456789876543210))-      where-        Fmap_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                            arg. SameKind (Apply Fmap_0123456789876543210Sym0 arg) (Fmap_0123456789876543210Sym1 arg) =>-                                                     Fmap_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Fmap_0123456789876543210Sym0 a0123456789876543210 = Fmap_0123456789876543210Sym1 a0123456789876543210-    type family Case_0123456789876543210 v_0123456789876543210 t where-    type family TFHelper_0123456789876543210 (a :: a) (a :: Empty b) :: Empty a where-      TFHelper_0123456789876543210 _ v_0123456789876543210 = Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210-    type TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Empty b0123456789876543210) =-        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                                            (~>) (Empty b0123456789876543210) (Empty a0123456789876543210)-      where-        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())-    data TFHelper_0123456789876543210Sym0 :: forall a0123456789876543210-                                                    b0123456789876543210.-                                             (~>) a0123456789876543210 ((~>) (Empty b0123456789876543210) (Empty a0123456789876543210))-      where-        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 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 family FoldMap_0123456789876543210 (a :: (~>) a m) (a :: Empty a) :: m where-      FoldMap_0123456789876543210 _ _ = MemptySym0-    type FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) (a0123456789876543210 :: Empty a0123456789876543210) =-        FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (FoldMap_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) FoldMap_0123456789876543210Sym1KindInference) ())-    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) :: (~>) (Empty a0123456789876543210) m0123456789876543210-      where-        FoldMap_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FoldMap_0123456789876543210Sym0KindInference) ())-    data FoldMap_0123456789876543210Sym0 :: forall a0123456789876543210-                                                   m0123456789876543210.-                                            (~>) ((~>) a0123456789876543210 m0123456789876543210) ((~>) (Empty a0123456789876543210) m0123456789876543210)-      where-        FoldMap_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply FoldMap_0123456789876543210Sym0 arg) (FoldMap_0123456789876543210Sym1 arg) =>-                                                        FoldMap_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FoldMap_0123456789876543210Sym0 a0123456789876543210 = FoldMap_0123456789876543210Sym1 a0123456789876543210-    instance PFoldable Empty where-      type FoldMap a a = Apply (Apply FoldMap_0123456789876543210Sym0 a) a-    type family Case_0123456789876543210 v_0123456789876543210 t where-    type family Traverse_0123456789876543210 (a :: (~>) a (f b)) (a :: Empty a) :: f (Empty b) where-      Traverse_0123456789876543210 _ v_0123456789876543210 = Apply PureSym0 (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)-    type Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: Empty a0123456789876543210) =-        Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Traverse_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Traverse_0123456789876543210Sym1KindInference) ())-    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) :: (~>) (Empty a0123456789876543210) (f0123456789876543210 (Empty b0123456789876543210))-      where-        Traverse_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Traverse_0123456789876543210Sym0KindInference) ())-    data Traverse_0123456789876543210Sym0 :: forall a0123456789876543210-                                                    b0123456789876543210-                                                    f0123456789876543210.-                                             (~>) ((~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) ((~>) (Empty a0123456789876543210) (f0123456789876543210 (Empty b0123456789876543210)))-      where-        Traverse_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply Traverse_0123456789876543210Sym0 arg) (Traverse_0123456789876543210Sym1 arg) =>-                                                         Traverse_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Traverse_0123456789876543210Sym0 a0123456789876543210 = Traverse_0123456789876543210Sym1 a0123456789876543210-    instance PTraversable Empty where-      type Traverse a a = Apply (Apply Traverse_0123456789876543210Sym0 a) a-    data instance Sing :: T x a -> Type-      where-        SMkT1 :: forall x-                        a-                        (n :: x)-                        (n :: a)-                        (n :: Maybe a)-                        (n :: Maybe (Maybe a)).-                 (Sing (n :: x))-                 -> (Sing (n :: a))-                    -> (Sing (n :: Maybe a))-                       -> (Sing (n :: Maybe (Maybe a))) -> Sing (MkT1 n n n n)-        SMkT2 :: forall x (n :: Maybe x).-                 (Sing (n :: Maybe x)) -> Sing (MkT2 n)-    type ST = (Sing :: T x a -> Type)-    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 instance Sing :: Empty a -> Type-    type SEmpty = (Sing :: Empty a -> Type)-    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 (m :: Type) (a :: 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 _f_0123456789876543210) _z_0123456789876543210) n1_0123456789876543210) n2_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 (f :: Type -> Type)-               (a :: 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)-        = (case sV_0123456789876543210 of) ::-            Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)-      (%<$) _ (sV_0123456789876543210 :: Sing v_0123456789876543210)-        = (case sV_0123456789876543210 of) ::-            Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)-    instance SFoldable Empty where-      sFoldMap ::-        forall (m :: Type) (a :: 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 (f :: Type -> Type)-               (a :: 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))-            ((case sV_0123456789876543210 of) ::-               Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210))-    instance (SingI n, SingI n, SingI n, SingI n) =>-             SingI (MkT1 (n :: x) (n :: a) (n :: Maybe a) (n :: Maybe (Maybe a))) where-      sing = (((SMkT1 sing) sing) sing) sing-    instance SingI (MkT1Sym0 :: (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))))) where-      sing = (singFun4 @MkT1Sym0) SMkT1-    instance SingI (TyCon4 MkT1 :: (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))))) where-      sing = (singFun4 @(TyCon4 MkT1)) SMkT1-    instance SingI d =>-             SingI (MkT1Sym1 (d :: x) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where-      sing = (singFun3 @(MkT1Sym1 (d :: x))) (SMkT1 (sing @d))-    instance SingI d =>-             SingI (TyCon3 (MkT1 (d :: x)) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where-      sing = (singFun3 @(TyCon3 (MkT1 (d :: x)))) (SMkT1 (sing @d))-    instance (SingI d, SingI d) =>-             SingI (MkT1Sym2 (d :: x) (d :: a) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where-      sing-        = (singFun2 @(MkT1Sym2 (d :: x) (d :: a)))-            ((SMkT1 (sing @d)) (sing @d))-    instance (SingI d, SingI d) =>-             SingI (TyCon2 (MkT1 (d :: x) (d :: a)) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where-      sing-        = (singFun2 @(TyCon2 (MkT1 (d :: x) (d :: a))))-            ((SMkT1 (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a) :: (~>) (Maybe (Maybe a)) (T x a)) where-      sing-        = (singFun1 @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a)))-            (((SMkT1 (sing @d)) (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (TyCon1 (MkT1 (d :: x) (d :: a) (d :: Maybe a)) :: (~>) (Maybe (Maybe a)) (T x a)) where-      sing-        = (singFun1 @(TyCon1 (MkT1 (d :: x) (d :: a) (d :: Maybe a))))-            (((SMkT1 (sing @d)) (sing @d)) (sing @d))-    instance SingI n => SingI (MkT2 (n :: Maybe x)) where-      sing = SMkT2 sing-    instance SingI (MkT2Sym0 :: (~>) (Maybe x) (T x a)) where-      sing = (singFun1 @MkT2Sym0) SMkT2-    instance SingI (TyCon1 MkT2 :: (~>) (Maybe x) (T x a)) where-      sing = (singFun1 @(TyCon1 MkT2)) SMkT2
+ tests/compile-and-dump/Singletons/FunctorLikeDeriving.ghc88.template view
@@ -0,0 +1,1632 @@+Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data T x a+            = MkT1 x a (Maybe a) (Maybe (Maybe a)) | MkT2 (Maybe x)+            deriving (Functor, Foldable, Traversable)+          data Empty (a :: Type) deriving (Functor, Foldable, Traversable) |]+  ======>+    data T x a+      = MkT1 x a (Maybe a) (Maybe (Maybe a)) | MkT2 (Maybe x)+      deriving (Functor, Foldable, Traversable)+    data Empty (a :: Type) deriving (Functor, Foldable, Traversable)+    type MkT1Sym4 (t0123456789876543210 :: x0123456789876543210) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: Maybe a0123456789876543210) (t0123456789876543210 :: Maybe (Maybe a0123456789876543210)) =+        MkT1 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkT1Sym3KindInference) ())+    data MkT1Sym3 (t0123456789876543210 :: x0123456789876543210) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: Maybe a0123456789876543210) :: (~>) (Maybe (Maybe a0123456789876543210)) (T x0123456789876543210 a0123456789876543210)+      where+        MkT1Sym3KindInference :: forall t0123456789876543210+                                        t0123456789876543210+                                        t0123456789876543210+                                        t0123456789876543210+                                        arg. SameKind (Apply (MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (MkT1Sym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                                 MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = MkT1 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkT1Sym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkT1Sym2KindInference) ())+    data MkT1Sym2 (t0123456789876543210 :: x0123456789876543210) (t0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) ((~>) (Maybe (Maybe a0123456789876543210)) (T x0123456789876543210 a0123456789876543210))+      where+        MkT1Sym2KindInference :: forall t0123456789876543210+                                        t0123456789876543210+                                        t0123456789876543210+                                        arg. SameKind (Apply (MkT1Sym2 t0123456789876543210 t0123456789876543210) arg) (MkT1Sym3 t0123456789876543210 t0123456789876543210 arg) =>+                                 MkT1Sym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (MkT1Sym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = MkT1Sym3 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkT1Sym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkT1Sym1KindInference) ())+    data MkT1Sym1 (t0123456789876543210 :: x0123456789876543210) :: forall a0123456789876543210.+                                                                    (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) ((~>) (Maybe (Maybe a0123456789876543210)) (T x0123456789876543210 a0123456789876543210)))+      where+        MkT1Sym1KindInference :: forall t0123456789876543210+                                        t0123456789876543210+                                        arg. SameKind (Apply (MkT1Sym1 t0123456789876543210) arg) (MkT1Sym2 t0123456789876543210 arg) =>+                                 MkT1Sym1 t0123456789876543210 t0123456789876543210+    type instance Apply (MkT1Sym1 t0123456789876543210) t0123456789876543210 = MkT1Sym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings MkT1Sym0 where+      suppressUnusedWarnings = snd (((,) MkT1Sym0KindInference) ())+    data MkT1Sym0 :: forall x0123456789876543210 a0123456789876543210.+                     (~>) x0123456789876543210 ((~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) ((~>) (Maybe (Maybe a0123456789876543210)) (T x0123456789876543210 a0123456789876543210))))+      where+        MkT1Sym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply MkT1Sym0 arg) (MkT1Sym1 arg) =>+                                 MkT1Sym0 t0123456789876543210+    type instance Apply MkT1Sym0 t0123456789876543210 = MkT1Sym1 t0123456789876543210+    type MkT2Sym1 (t0123456789876543210 :: Maybe x0123456789876543210) =+        MkT2 t0123456789876543210+    instance SuppressUnusedWarnings MkT2Sym0 where+      suppressUnusedWarnings = snd (((,) MkT2Sym0KindInference) ())+    data MkT2Sym0 :: forall x0123456789876543210 a0123456789876543210.+                     (~>) (Maybe x0123456789876543210) (T x0123456789876543210 a0123456789876543210)+      where+        MkT2Sym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply MkT2Sym0 arg) (MkT2Sym1 arg) =>+                                 MkT2Sym0 t0123456789876543210+    type instance Apply MkT2Sym0 t0123456789876543210 = MkT2 t0123456789876543210+    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t where+      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210+    type Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())+    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210+    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 t where+      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210+    type Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210+    type family Fmap_0123456789876543210 (a :: (~>) a0 b0) (a :: T x a0) :: T x b0 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_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100 b01234567898765432100) (a0123456789876543210 :: T x0123456789876543210 a01234567898765432100) =+        Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Fmap_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Fmap_0123456789876543210Sym1KindInference) ())+    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100 b01234567898765432100) :: forall x0123456789876543210.+                                                                                                                    (~>) (T x0123456789876543210 a01234567898765432100) (T x0123456789876543210 b01234567898765432100)+      where+        Fmap_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                            a0123456789876543210+                                                            arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Fmap_0123456789876543210Sym0KindInference) ())+    data Fmap_0123456789876543210Sym0 :: forall a01234567898765432100+                                                b01234567898765432100+                                                x0123456789876543210.+                                         (~>) ((~>) a01234567898765432100 b01234567898765432100) ((~>) (T x0123456789876543210 a01234567898765432100) (T x0123456789876543210 b01234567898765432100))+      where+        Fmap_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                            arg. SameKind (Apply Fmap_0123456789876543210Sym0 arg) (Fmap_0123456789876543210Sym1 arg) =>+                                                     Fmap_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Fmap_0123456789876543210Sym0 a0123456789876543210 = Fmap_0123456789876543210Sym1 a0123456789876543210+    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t where+      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210+    type Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())+    data Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym5KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _z_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210+    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t where+      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = _z_0123456789876543210+    type Lambda_0123456789876543210Sym6 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())+    data Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym5KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _z_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210+    type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 t where+      Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210+    type Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _z_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _z_01234567898765432100123456789876543210+    type family TFHelper_0123456789876543210 (a :: a0) (a :: T x b0) :: T x a0 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_0123456789876543210Sym2 (a0123456789876543210 :: a01234567898765432100) (a0123456789876543210 :: T x0123456789876543210 b01234567898765432100) =+        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())+    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a01234567898765432100) :: forall x0123456789876543210+                                                                                                    b01234567898765432100.+                                                                                             (~>) (T x0123456789876543210 b01234567898765432100) (T x0123456789876543210 a01234567898765432100)+      where+        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())+    data TFHelper_0123456789876543210Sym0 :: forall a01234567898765432100+                                                    x0123456789876543210+                                                    b01234567898765432100.+                                             (~>) a01234567898765432100 ((~>) (T x0123456789876543210 b01234567898765432100) (T x0123456789876543210 a01234567898765432100))+      where+        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>+                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210+    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210+    instance PFunctor (T x) where+      type Fmap a a = Apply (Apply Fmap_0123456789876543210Sym0 a) a+      type (<$) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a+    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t where+      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = MemptySym0+    type Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())+    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210+    type family Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 t where+      Lambda_0123456789876543210 _f_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = MemptySym0+    type Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210+    type family FoldMap_0123456789876543210 (a :: (~>) a0 m0) (a :: T x a0) :: m0 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_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100 m01234567898765432100) (a0123456789876543210 :: T x0123456789876543210 a01234567898765432100) =+        FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (FoldMap_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) FoldMap_0123456789876543210Sym1KindInference) ())+    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100 m01234567898765432100) :: forall x0123456789876543210.+                                                                                                                       (~>) (T x0123456789876543210 a01234567898765432100) m01234567898765432100+      where+        FoldMap_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FoldMap_0123456789876543210Sym0KindInference) ())+    data FoldMap_0123456789876543210Sym0 :: forall a01234567898765432100+                                                   m01234567898765432100+                                                   x0123456789876543210.+                                            (~>) ((~>) a01234567898765432100 m01234567898765432100) ((~>) (T x0123456789876543210 a01234567898765432100) m01234567898765432100)+      where+        FoldMap_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply FoldMap_0123456789876543210Sym0 arg) (FoldMap_0123456789876543210Sym1 arg) =>+                                                        FoldMap_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FoldMap_0123456789876543210Sym0 a0123456789876543210 = FoldMap_0123456789876543210Sym1 a0123456789876543210+    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t where+      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = n2_0123456789876543210+    type Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())+    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym7KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())+    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym6KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())+    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210+    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t 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+    type Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())+    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym7KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())+    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym6KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())+    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210+    type family Lambda_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t 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+    type Lambda_0123456789876543210Sym10 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym9 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym9KindInference) ())+    data Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym9KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym10 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym9 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym9 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym8 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym8KindInference) ())+    data Lambda_0123456789876543210Sym8 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym8KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym8 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym9 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())+    data Lambda_0123456789876543210Sym7 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym7KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym8 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())+    data Lambda_0123456789876543210Sym6 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym6KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())+    data Lambda_0123456789876543210Sym5 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym5KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              arg. 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 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) _z_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              _f_01234567898765432100123456789876543210+                                                              arg. 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 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 n2_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall n1_01234567898765432100123456789876543210+                                                              n2_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 n1_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall n1_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 n1_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 n1_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 n1_01234567898765432100123456789876543210+    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t 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+    type Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym7KindInference) ())+    data Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym7KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym8 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym7 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym7 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym6KindInference) ())+    data Lambda_0123456789876543210Sym6 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym6KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym7 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym5KindInference) ())+    data Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym5KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym6 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210+    type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 t t where+      Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = n2_0123456789876543210+    type Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 t0123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym4 t0123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. 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 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210) a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _z_01234567898765432100123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall _f_01234567898765432100123456789876543210+                                                              _z_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall _f_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 _f_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 _f_01234567898765432100123456789876543210+    type family Foldr_0123456789876543210 (a :: (~>) a0 ((~>) b0 b0)) (a :: b0) (a :: T x a0) :: b0 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_0123456789876543210Sym3 (a0123456789876543210 :: (~>) a01234567898765432100 ((~>) b01234567898765432100 b01234567898765432100)) (a0123456789876543210 :: b01234567898765432100) (a0123456789876543210 :: T x0123456789876543210 a01234567898765432100) =+        Foldr_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Foldr_0123456789876543210Sym2KindInference) ())+    data Foldr_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100 ((~>) b01234567898765432100 b01234567898765432100)) (a0123456789876543210 :: b01234567898765432100) :: forall x0123456789876543210.+                                                                                                                                                                                                  (~>) (T x0123456789876543210 a01234567898765432100) b01234567898765432100+      where+        Foldr_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                             a0123456789876543210+                                                             a0123456789876543210+                                                             arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Foldr_0123456789876543210Sym1KindInference) ())+    data Foldr_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100 ((~>) b01234567898765432100 b01234567898765432100)) :: forall x0123456789876543210.+                                                                                                                                                  (~>) b01234567898765432100 ((~>) (T x0123456789876543210 a01234567898765432100) b01234567898765432100)+      where+        Foldr_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                             a0123456789876543210+                                                             arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Foldr_0123456789876543210Sym0KindInference) ())+    data Foldr_0123456789876543210Sym0 :: forall a01234567898765432100+                                                 b01234567898765432100+                                                 x0123456789876543210.+                                          (~>) ((~>) a01234567898765432100 ((~>) b01234567898765432100 b01234567898765432100)) ((~>) b01234567898765432100 ((~>) (T x0123456789876543210 a01234567898765432100) b01234567898765432100))+      where+        Foldr_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                             arg. SameKind (Apply Foldr_0123456789876543210Sym0 arg) (Foldr_0123456789876543210Sym1 arg) =>+                                                      Foldr_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Foldr_0123456789876543210Sym0 a0123456789876543210 = Foldr_0123456789876543210Sym1 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 family Traverse_0123456789876543210 (a :: (~>) a0 (f0 b0)) (a :: T x a0) :: f0 (T x b0) 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_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100 (f01234567898765432100 b01234567898765432100)) (a0123456789876543210 :: T x0123456789876543210 a01234567898765432100) =+        Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Traverse_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Traverse_0123456789876543210Sym1KindInference) ())+    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100 (f01234567898765432100 b01234567898765432100)) :: forall x0123456789876543210.+                                                                                                                                                (~>) (T x0123456789876543210 a01234567898765432100) (f01234567898765432100 (T x0123456789876543210 b01234567898765432100))+      where+        Traverse_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Traverse_0123456789876543210Sym0KindInference) ())+    data Traverse_0123456789876543210Sym0 :: forall a01234567898765432100+                                                    f01234567898765432100+                                                    b01234567898765432100+                                                    x0123456789876543210.+                                             (~>) ((~>) a01234567898765432100 (f01234567898765432100 b01234567898765432100)) ((~>) (T x0123456789876543210 a01234567898765432100) (f01234567898765432100 (T x0123456789876543210 b01234567898765432100)))+      where+        Traverse_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply Traverse_0123456789876543210Sym0 arg) (Traverse_0123456789876543210Sym1 arg) =>+                                                         Traverse_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Traverse_0123456789876543210Sym0 a0123456789876543210 = Traverse_0123456789876543210Sym1 a0123456789876543210+    instance PTraversable (T x) where+      type Traverse a a = Apply (Apply Traverse_0123456789876543210Sym0 a) a+    type family Case_0123456789876543210 v_0123456789876543210 t where+    type family Fmap_0123456789876543210 (a :: (~>) a0 b0) (a :: Empty a0) :: Empty b0 where+      Fmap_0123456789876543210 _ v_0123456789876543210 = Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210+    type Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100 b01234567898765432100) (a0123456789876543210 :: Empty a01234567898765432100) =+        Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Fmap_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Fmap_0123456789876543210Sym1KindInference) ())+    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100 b01234567898765432100) :: (~>) (Empty a01234567898765432100) (Empty b01234567898765432100)+      where+        Fmap_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                            a0123456789876543210+                                                            arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Fmap_0123456789876543210Sym0KindInference) ())+    data Fmap_0123456789876543210Sym0 :: forall a01234567898765432100+                                                b01234567898765432100.+                                         (~>) ((~>) a01234567898765432100 b01234567898765432100) ((~>) (Empty a01234567898765432100) (Empty b01234567898765432100))+      where+        Fmap_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                            arg. SameKind (Apply Fmap_0123456789876543210Sym0 arg) (Fmap_0123456789876543210Sym1 arg) =>+                                                     Fmap_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Fmap_0123456789876543210Sym0 a0123456789876543210 = Fmap_0123456789876543210Sym1 a0123456789876543210+    type family Case_0123456789876543210 v_0123456789876543210 t where+    type family TFHelper_0123456789876543210 (a :: a0) (a :: Empty b0) :: Empty a0 where+      TFHelper_0123456789876543210 _ v_0123456789876543210 = Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210+    type TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: a01234567898765432100) (a0123456789876543210 :: Empty b01234567898765432100) =+        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())+    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: a01234567898765432100) :: forall b01234567898765432100.+                                                                                             (~>) (Empty b01234567898765432100) (Empty a01234567898765432100)+      where+        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())+    data TFHelper_0123456789876543210Sym0 :: forall a01234567898765432100+                                                    b01234567898765432100.+                                             (~>) a01234567898765432100 ((~>) (Empty b01234567898765432100) (Empty a01234567898765432100))+      where+        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>+                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210+    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 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 family FoldMap_0123456789876543210 (a :: (~>) a0 m0) (a :: Empty a0) :: m0 where+      FoldMap_0123456789876543210 _ _ = MemptySym0+    type FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100 m01234567898765432100) (a0123456789876543210 :: Empty a01234567898765432100) =+        FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (FoldMap_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) FoldMap_0123456789876543210Sym1KindInference) ())+    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100 m01234567898765432100) :: (~>) (Empty a01234567898765432100) m01234567898765432100+      where+        FoldMap_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FoldMap_0123456789876543210Sym0KindInference) ())+    data FoldMap_0123456789876543210Sym0 :: forall a01234567898765432100+                                                   m01234567898765432100.+                                            (~>) ((~>) a01234567898765432100 m01234567898765432100) ((~>) (Empty a01234567898765432100) m01234567898765432100)+      where+        FoldMap_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply FoldMap_0123456789876543210Sym0 arg) (FoldMap_0123456789876543210Sym1 arg) =>+                                                        FoldMap_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FoldMap_0123456789876543210Sym0 a0123456789876543210 = FoldMap_0123456789876543210Sym1 a0123456789876543210+    instance PFoldable Empty where+      type FoldMap a a = Apply (Apply FoldMap_0123456789876543210Sym0 a) a+    type family Case_0123456789876543210 v_0123456789876543210 t where+    type family Traverse_0123456789876543210 (a :: (~>) a0 (f0 b0)) (a :: Empty a0) :: f0 (Empty b0) where+      Traverse_0123456789876543210 _ v_0123456789876543210 = Apply PureSym0 (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)+    type Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100 (f01234567898765432100 b01234567898765432100)) (a0123456789876543210 :: Empty a01234567898765432100) =+        Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Traverse_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Traverse_0123456789876543210Sym1KindInference) ())+    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100 (f01234567898765432100 b01234567898765432100)) :: (~>) (Empty a01234567898765432100) (f01234567898765432100 (Empty b01234567898765432100))+      where+        Traverse_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Traverse_0123456789876543210Sym0KindInference) ())+    data Traverse_0123456789876543210Sym0 :: forall a01234567898765432100+                                                    f01234567898765432100+                                                    b01234567898765432100.+                                             (~>) ((~>) a01234567898765432100 (f01234567898765432100 b01234567898765432100)) ((~>) (Empty a01234567898765432100) (f01234567898765432100 (Empty b01234567898765432100)))+      where+        Traverse_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply Traverse_0123456789876543210Sym0 arg) (Traverse_0123456789876543210Sym1 arg) =>+                                                         Traverse_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Traverse_0123456789876543210Sym0 a0123456789876543210 = Traverse_0123456789876543210Sym1 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 :: x))+                 -> (Sing (n :: a))+                    -> (Sing (n :: Maybe a))+                       -> (Sing (n :: Maybe (Maybe a))) -> ST (MkT1 n n n n)+        SMkT2 :: forall x (n :: Maybe x).+                 (Sing (n :: Maybe x)) -> ST (MkT2 n)+    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. Empty a -> Type+    type instance Sing @(Empty a) = SEmpty+    instance SingKind a => SingKind (Empty a) where+      type Demote (Empty a) = Empty (Demote a)+      fromSing x = case x of+      toSing x = SomeSing (case x of)+    instance SFunctor (T x) where+      sFmap ::+        forall (a :: Type) (b :: Type) (t1 :: (~>) a b) (t2 :: T x a).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (FmapSym0 :: TyFun ((~>) a b) ((~>) (T x a) (T x b))+                                              -> Type) t1) t2)+      (%<$) ::+        forall (a :: Type) (b :: Type) (t1 :: a) (t2 :: T x b).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply ((<$@#@$) :: TyFun a ((~>) (T x b) (T x a))+                                              -> Type) t1) t2)+      sFmap+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing+                     ((applySing ((singFun4 @MkT1Sym0) SMkT1))+                        ((applySing+                            ((singFun1+                                @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))+                               (\ sN_0123456789876543210+                                  -> case sN_0123456789876543210 of {+                                       (_ :: Sing n_0123456789876543210)+                                         -> sN_0123456789876543210 })))+                           sA_0123456789876543210)))+                    ((applySing _sf_0123456789876543210) sA_0123456789876543210)))+                ((applySing+                    ((applySing ((singFun2 @FmapSym0) sFmap)) _sf_0123456789876543210))+                   sA_0123456789876543210)))+            ((applySing+                ((applySing ((singFun2 @FmapSym0) sFmap))+                   ((applySing ((singFun2 @FmapSym0) sFmap))+                      _sf_0123456789876543210)))+               sA_0123456789876543210)+      sFmap+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing ((singFun1 @MkT2Sym0) SMkT2))+            ((applySing+                ((singFun1+                    @(Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210))+                   (\ sN_0123456789876543210+                      -> case sN_0123456789876543210 of {+                           (_ :: Sing n_0123456789876543210) -> sN_0123456789876543210 })))+               sA_0123456789876543210)+      (%<$)+        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing+                     ((applySing ((singFun4 @MkT1Sym0) SMkT1))+                        ((applySing+                            ((singFun1+                                @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))+                               (\ sN_0123456789876543210+                                  -> case sN_0123456789876543210 of {+                                       (_ :: Sing n_0123456789876543210)+                                         -> sN_0123456789876543210 })))+                           sA_0123456789876543210)))+                    ((applySing+                        ((singFun1+                            @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))+                           (\ sN_0123456789876543210+                              -> case sN_0123456789876543210 of {+                                   (_ :: Sing n_0123456789876543210) -> _sz_0123456789876543210 })))+                       sA_0123456789876543210)))+                ((applySing+                    ((applySing ((singFun2 @(<$@#@$)) (%<$))) _sz_0123456789876543210))+                   sA_0123456789876543210)))+            ((applySing+                ((applySing ((singFun2 @FmapSym0) sFmap))+                   ((applySing ((singFun2 @(<$@#@$)) (%<$)))+                      _sz_0123456789876543210)))+               sA_0123456789876543210)+      (%<$)+        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing ((singFun1 @MkT2Sym0) SMkT2))+            ((applySing+                ((singFun1+                    @(Apply (Apply Lambda_0123456789876543210Sym0 _z_0123456789876543210) a_0123456789876543210))+                   (\ sN_0123456789876543210+                      -> case sN_0123456789876543210 of {+                           (_ :: Sing n_0123456789876543210) -> sN_0123456789876543210 })))+               sA_0123456789876543210)+    instance SFoldable (T x) where+      sFoldMap ::+        forall (a :: Type) (m :: Type) (t1 :: (~>) a m) (t2 :: T x a).+        SMonoid m =>+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (FoldMapSym0 :: TyFun ((~>) a m) ((~>) (T x a) m)+                                                 -> Type) t1) t2)+      sFoldr ::+        forall (a :: Type)+               (b :: Type)+               (t1 :: (~>) a ((~>) b b))+               (t2 :: b)+               (t3 :: T x a).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (FoldrSym0 :: TyFun ((~>) a ((~>) b b)) ((~>) b ((~>) (T x a) b))+                                                         -> Type) t1) t2) t3)+      sFoldMap+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing+             ((applySing ((singFun2 @MappendSym0) sMappend))+                ((applySing+                    ((singFun1+                        @(Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))+                       (\ sN_0123456789876543210+                          -> case sN_0123456789876543210 of {+                               (_ :: Sing n_0123456789876543210) -> sMempty })))+                   sA_0123456789876543210)))+            ((applySing+                ((applySing ((singFun2 @MappendSym0) sMappend))+                   ((applySing _sf_0123456789876543210) sA_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @MappendSym0) sMappend))+                      ((applySing+                          ((applySing ((singFun2 @FoldMapSym0) sFoldMap))+                             _sf_0123456789876543210))+                         sA_0123456789876543210)))+                  ((applySing+                      ((applySing ((singFun2 @FoldMapSym0) sFoldMap))+                         ((applySing ((singFun2 @FoldMapSym0) sFoldMap))+                            _sf_0123456789876543210)))+                     sA_0123456789876543210)))+      sFoldMap+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing+             ((singFun1+                 @(Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210))+                (\ sN_0123456789876543210+                   -> case sN_0123456789876543210 of {+                        (_ :: Sing n_0123456789876543210) -> sMempty })))+            sA_0123456789876543210+      sFoldr+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)+        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing+             ((applySing+                 ((singFun2+                     @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))+                    (\ sN1_0123456789876543210 sN2_0123456789876543210+                       -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of {+                            (,) (_ :: Sing n1_0123456789876543210)+                                (_ :: Sing n2_0123456789876543210)+                              -> sN2_0123456789876543210 })))+                sA_0123456789876543210))+            ((applySing+                ((applySing _sf_0123456789876543210) sA_0123456789876543210))+               ((applySing+                   ((applySing+                       ((singFun2+                           @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))+                          (\ sN1_0123456789876543210 sN2_0123456789876543210+                             -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of {+                                  (,) (_ :: Sing n1_0123456789876543210)+                                      (_ :: Sing n2_0123456789876543210)+                                    -> (applySing+                                          ((applySing+                                              ((applySing ((singFun3 @FoldrSym0) sFoldr))+                                                 _sf_0123456789876543210))+                                             sN2_0123456789876543210))+                                         sN1_0123456789876543210 })))+                      sA_0123456789876543210))+                  ((applySing+                      ((applySing+                          ((singFun2+                              @(Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))+                             (\ sN1_0123456789876543210 sN2_0123456789876543210+                                -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of {+                                     (,) (_ :: Sing n1_0123456789876543210)+                                         (_ :: Sing n2_0123456789876543210)+                                       -> (applySing+                                             ((applySing+                                                 ((applySing ((singFun3 @FoldrSym0) sFoldr))+                                                    ((singFun2+                                                        @(Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 n1_0123456789876543210) n2_0123456789876543210) _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210))+                                                       (\ sN1_0123456789876543210+                                                          sN2_0123456789876543210+                                                          -> case+                                                                 ((,) sN1_0123456789876543210)+                                                                   sN2_0123456789876543210+                                                             of {+                                                               (,) (_ :: Sing n1_0123456789876543210)+                                                                   (_ :: Sing n2_0123456789876543210)+                                                                 -> (applySing+                                                                       ((applySing+                                                                           ((applySing+                                                                               ((singFun3+                                                                                   @FoldrSym0)+                                                                                  sFoldr))+                                                                              _sf_0123456789876543210))+                                                                          sN2_0123456789876543210))+                                                                      sN1_0123456789876543210 }))))+                                                sN2_0123456789876543210))+                                            sN1_0123456789876543210 })))+                         sA_0123456789876543210))+                     _sz_0123456789876543210)))+      sFoldr+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)+        (_sz_0123456789876543210 :: Sing _z_0123456789876543210)+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing+             ((applySing+                 ((singFun2+                     @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210))+                    (\ sN1_0123456789876543210 sN2_0123456789876543210+                       -> case ((,) sN1_0123456789876543210) sN2_0123456789876543210 of {+                            (,) (_ :: Sing n1_0123456789876543210)+                                (_ :: Sing n2_0123456789876543210)+                              -> sN2_0123456789876543210 })))+                sA_0123456789876543210))+            _sz_0123456789876543210+    instance STraversable (T x) where+      sTraverse ::+        forall (a :: Type)+               (f :: Type -> Type)+               (b :: Type)+               (t1 :: (~>) a (f b))+               (t2 :: T x a).+        SApplicative f =>+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (TraverseSym0 :: TyFun ((~>) a (f b)) ((~>) (T x a) (f (T x b)))+                                                  -> Type) t1) t2)+      sTraverse+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)+        (SMkT1 (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210)+               (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing+             ((applySing ((singFun2 @(<*>@#@$)) (%<*>)))+                ((applySing+                    ((applySing ((singFun2 @(<*>@#@$)) (%<*>)))+                       ((applySing+                           ((applySing+                               ((applySing ((singFun3 @LiftA2Sym0) sLiftA2))+                                  ((singFun4 @MkT1Sym0) SMkT1)))+                              ((applySing ((singFun1 @PureSym0) sPure)) sA_0123456789876543210)))+                          ((applySing _sf_0123456789876543210) sA_0123456789876543210))))+                   ((applySing+                       ((applySing ((singFun2 @TraverseSym0) sTraverse))+                          _sf_0123456789876543210))+                      sA_0123456789876543210))))+            ((applySing+                ((applySing ((singFun2 @TraverseSym0) sTraverse))+                   ((applySing ((singFun2 @TraverseSym0) sTraverse))+                      _sf_0123456789876543210)))+               sA_0123456789876543210)+      sTraverse+        (_sf_0123456789876543210 :: Sing _f_0123456789876543210)+        (SMkT2 (sA_0123456789876543210 :: Sing a_0123456789876543210))+        = (applySing+             ((applySing ((singFun2 @FmapSym0) sFmap))+                ((singFun1 @MkT2Sym0) SMkT2)))+            ((applySing ((singFun1 @PureSym0) sPure)) sA_0123456789876543210)+    instance SFunctor Empty where+      sFmap ::+        forall (a :: Type) (b :: Type) (t1 :: (~>) a b) (t2 :: Empty a).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (FmapSym0 :: TyFun ((~>) a b) ((~>) (Empty a) (Empty b))+                                              -> Type) t1) t2)+      (%<$) ::+        forall (a :: Type) (b :: Type) (t1 :: a) (t2 :: Empty b).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply ((<$@#@$) :: TyFun a ((~>) (Empty b) (Empty a))+                                              -> Type) t1) t2)+      sFmap _ (sV_0123456789876543210 :: Sing v_0123456789876543210)+        = (id+             @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)))+            (case sV_0123456789876543210 of)+      (%<$) _ (sV_0123456789876543210 :: Sing v_0123456789876543210)+        = (id+             @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)))+            (case sV_0123456789876543210 of)+    instance SFoldable Empty where+      sFoldMap ::+        forall (a :: Type) (m :: Type) (t1 :: (~>) a m) (t2 :: Empty a).+        SMonoid m =>+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (FoldMapSym0 :: TyFun ((~>) a m) ((~>) (Empty a) m)+                                                 -> Type) t1) t2)+      sFoldMap _ _ = sMempty+    instance STraversable Empty where+      sTraverse ::+        forall (a :: Type)+               (f :: Type -> Type)+               (b :: Type)+               (t1 :: (~>) a (f b))+               (t2 :: Empty a).+        SApplicative f =>+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (TraverseSym0 :: TyFun ((~>) a (f b)) ((~>) (Empty a) (f (Empty b)))+                                                  -> Type) t1) t2)+      sTraverse _ (sV_0123456789876543210 :: Sing v_0123456789876543210)+        = (applySing ((singFun1 @PureSym0) sPure))+            ((id+                @(Sing (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)))+               (case sV_0123456789876543210 of))+    instance (SingI n, SingI n, SingI n, SingI n) =>+             SingI (MkT1 (n :: x) (n :: a) (n :: Maybe a) (n :: Maybe (Maybe a))) where+      sing = (((SMkT1 sing) sing) sing) sing+    instance SingI (MkT1Sym0 :: (~>) x ((~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))))) where+      sing = (singFun4 @MkT1Sym0) SMkT1+    instance SingI d =>+             SingI (MkT1Sym1 (d :: x) :: (~>) a ((~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a)))) where+      sing = (singFun3 @(MkT1Sym1 (d :: x))) (SMkT1 (sing @d))+    instance (SingI d, SingI d) =>+             SingI (MkT1Sym2 (d :: x) (d :: a) :: (~>) (Maybe a) ((~>) (Maybe (Maybe a)) (T x a))) where+      sing+        = (singFun2 @(MkT1Sym2 (d :: x) (d :: a)))+            ((SMkT1 (sing @d)) (sing @d))+    instance (SingI d, SingI d, SingI d) =>+             SingI (MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a) :: (~>) (Maybe (Maybe a)) (T x a)) where+      sing+        = (singFun1 @(MkT1Sym3 (d :: x) (d :: a) (d :: Maybe a)))+            (((SMkT1 (sing @d)) (sing @d)) (sing @d))+    instance SingI n => SingI (MkT2 (n :: Maybe x)) where+      sing = SMkT2 sing+    instance SingI (MkT2Sym0 :: (~>) (Maybe x) (T x a)) where+      sing = (singFun1 @MkT2Sym0) SMkT2
− tests/compile-and-dump/Singletons/HigherOrder.ghc86.template 
@@ -1,480 +0,0 @@-Singletons/HigherOrder.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| map :: (a -> b) -> [a] -> [b]-          map _ [] = []-          map f (h : t) = (f h) : (map f t)-          liftMaybe :: (a -> b) -> Maybe a -> Maybe b-          liftMaybe f (Just x) = Just (f x)-          liftMaybe _ Nothing = Nothing-          zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]-          zipWith f (x : xs) (y : ys) = f x y : zipWith f xs ys-          zipWith _ [] [] = []-          zipWith _ (_ : _) [] = []-          zipWith _ [] (_ : _) = []-          foo :: ((a -> b) -> a -> b) -> (a -> b) -> a -> b-          foo f g a = f g a-          splunge :: [Nat] -> [Bool] -> [Nat]-          splunge ns bs-            = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs-          etad :: [Nat] -> [Bool] -> [Nat]-          etad = zipWith (\ n b -> if b then Succ (Succ n) else n)-          -          data Either a b = Left a | Right b |]-  ======>-    data Either a b = Left a | Right b-    map :: (a -> b) -> [a] -> [b]-    map _ [] = []-    map f (h : t) = (f h : (map f) t)-    liftMaybe :: (a -> b) -> Maybe a -> Maybe b-    liftMaybe f (Just x) = Just (f x)-    liftMaybe _ Nothing = Nothing-    zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]-    zipWith f (x : xs) (y : ys) = ((f x) y : ((zipWith f) xs) ys)-    zipWith _ [] [] = []-    zipWith _ (_ : _) [] = []-    zipWith _ [] (_ : _) = []-    foo :: ((a -> b) -> a -> b) -> (a -> b) -> a -> b-    foo f g a = (f g) a-    splunge :: [Nat] -> [Bool] -> [Nat]-    splunge ns bs-      = ((zipWith (\ n b -> if b then Succ (Succ n) else n)) ns) bs-    etad :: [Nat] -> [Bool] -> [Nat]-    etad = zipWith (\ n b -> if b then Succ (Succ n) else n)-    type LeftSym1 (t0123456789876543210 :: a0123456789876543210) =-        Left t0123456789876543210-    instance SuppressUnusedWarnings LeftSym0 where-      suppressUnusedWarnings = snd (((,) LeftSym0KindInference) ())-    data LeftSym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 (Either a0123456789876543210 b0123456789876543210)-      where-        LeftSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply LeftSym0 arg) (LeftSym1 arg) =>-                                 LeftSym0 t0123456789876543210-    type instance Apply LeftSym0 t0123456789876543210 = Left t0123456789876543210-    type RightSym1 (t0123456789876543210 :: b0123456789876543210) =-        Right t0123456789876543210-    instance SuppressUnusedWarnings RightSym0 where-      suppressUnusedWarnings = snd (((,) RightSym0KindInference) ())-    data RightSym0 :: forall a0123456789876543210 b0123456789876543210.-                      (~>) b0123456789876543210 (Either a0123456789876543210 b0123456789876543210)-      where-        RightSym0KindInference :: forall t0123456789876543210-                                         arg. SameKind (Apply RightSym0 arg) (RightSym1 arg) =>-                                  RightSym0 t0123456789876543210-    type instance Apply RightSym0 t0123456789876543210 = Right t0123456789876543210-    type family Case_0123456789876543210 ns bs n b t where-      Case_0123456789876543210 ns bs n b  'True = Apply SuccSym0 (Apply SuccSym0 n)-      Case_0123456789876543210 ns bs n b  'False = n-    type family Lambda_0123456789876543210 ns bs t t where-      Lambda_0123456789876543210 ns bs n b = Case_0123456789876543210 ns bs n b b-    type Lambda_0123456789876543210Sym4 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 t0123456789876543210 bs0123456789876543210 ns0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall ns0123456789876543210-                                                              bs0123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym4 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 t0123456789876543210 bs0123456789876543210 ns0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 bs0123456789876543210 ns0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 bs0123456789876543210 ns0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall ns0123456789876543210-                                                              bs0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210) arg) (Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 bs0123456789876543210 ns0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym3 bs0123456789876543210 ns0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 ns0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall ns0123456789876543210-                                                              bs0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 ns0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall ns0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 ns0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 ns0123456789876543210 = Lambda_0123456789876543210Sym1 ns0123456789876543210-    type family Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 t where-      Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210  'True = Apply SuccSym0 (Apply SuccSym0 n)-      Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210  'False = n-    type family Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t where-      Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n b = Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 b-    type Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall a_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210-    type FooSym3 (a0123456789876543210 :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: a0123456789876543210) =-        Foo a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (FooSym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FooSym2KindInference) ())-    data FooSym2 (a0123456789876543210 :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) a0123456789876543210 b0123456789876543210-      where-        FooSym2KindInference :: forall a0123456789876543210-                                       a0123456789876543210-                                       a0123456789876543210-                                       arg. 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-    instance SuppressUnusedWarnings (FooSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FooSym1KindInference) ())-    data FooSym1 (a0123456789876543210 :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)) :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)-      where-        FooSym1KindInference :: forall a0123456789876543210-                                       a0123456789876543210-                                       arg. SameKind (Apply (FooSym1 a0123456789876543210) arg) (FooSym2 a0123456789876543210 arg) =>-                                FooSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (FooSym1 a0123456789876543210) a0123456789876543210 = FooSym2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: forall a0123456789876543210 b0123456789876543210.-                    (~>) ((~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)) ((~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210))-      where-        FooSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = FooSym1 a0123456789876543210-    type ZipWithSym3 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 c0123456789876543210)) (a0123456789876543210 :: [a0123456789876543210]) (a0123456789876543210 :: [b0123456789876543210]) =-        ZipWith a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ZipWithSym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ZipWithSym2KindInference) ())-    data ZipWithSym2 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 c0123456789876543210)) (a0123456789876543210 :: [a0123456789876543210]) :: (~>) [b0123456789876543210] [c0123456789876543210]-      where-        ZipWithSym2KindInference :: forall a0123456789876543210-                                           a0123456789876543210-                                           a0123456789876543210-                                           arg. 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-    instance SuppressUnusedWarnings (ZipWithSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ZipWithSym1KindInference) ())-    data ZipWithSym1 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 c0123456789876543210)) :: (~>) [a0123456789876543210] ((~>) [b0123456789876543210] [c0123456789876543210])-      where-        ZipWithSym1KindInference :: forall a0123456789876543210-                                           a0123456789876543210-                                           arg. SameKind (Apply (ZipWithSym1 a0123456789876543210) arg) (ZipWithSym2 a0123456789876543210 arg) =>-                                    ZipWithSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (ZipWithSym1 a0123456789876543210) a0123456789876543210 = ZipWithSym2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ZipWithSym0 where-      suppressUnusedWarnings = snd (((,) ZipWithSym0KindInference) ())-    data ZipWithSym0 :: forall a0123456789876543210-                               b0123456789876543210-                               c0123456789876543210.-                        (~>) ((~>) a0123456789876543210 ((~>) b0123456789876543210 c0123456789876543210)) ((~>) [a0123456789876543210] ((~>) [b0123456789876543210] [c0123456789876543210]))-      where-        ZipWithSym0KindInference :: forall a0123456789876543210-                                           arg. SameKind (Apply ZipWithSym0 arg) (ZipWithSym1 arg) =>-                                    ZipWithSym0 a0123456789876543210-    type instance Apply ZipWithSym0 a0123456789876543210 = ZipWithSym1 a0123456789876543210-    type SplungeSym2 (a0123456789876543210 :: [Nat]) (a0123456789876543210 :: [Bool]) =-        Splunge a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (SplungeSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) SplungeSym1KindInference) ())-    data SplungeSym1 (a0123456789876543210 :: [Nat]) :: (~>) [Bool] [Nat]-      where-        SplungeSym1KindInference :: forall a0123456789876543210-                                           a0123456789876543210-                                           arg. SameKind (Apply (SplungeSym1 a0123456789876543210) arg) (SplungeSym2 a0123456789876543210 arg) =>-                                    SplungeSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (SplungeSym1 a0123456789876543210) a0123456789876543210 = Splunge a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings SplungeSym0 where-      suppressUnusedWarnings = snd (((,) SplungeSym0KindInference) ())-    data SplungeSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])-      where-        SplungeSym0KindInference :: forall a0123456789876543210-                                           arg. SameKind (Apply SplungeSym0 arg) (SplungeSym1 arg) =>-                                    SplungeSym0 a0123456789876543210-    type instance Apply SplungeSym0 a0123456789876543210 = SplungeSym1 a0123456789876543210-    type EtadSym2 (a0123456789876543210 :: [Nat]) (a0123456789876543210 :: [Bool]) =-        Etad a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (EtadSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) EtadSym1KindInference) ())-    data EtadSym1 (a0123456789876543210 :: [Nat]) :: (~>) [Bool] [Nat]-      where-        EtadSym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (EtadSym1 a0123456789876543210) arg) (EtadSym2 a0123456789876543210 arg) =>-                                 EtadSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (EtadSym1 a0123456789876543210) a0123456789876543210 = Etad a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings EtadSym0 where-      suppressUnusedWarnings = snd (((,) EtadSym0KindInference) ())-    data EtadSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])-      where-        EtadSym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply EtadSym0 arg) (EtadSym1 arg) =>-                                 EtadSym0 a0123456789876543210-    type instance Apply EtadSym0 a0123456789876543210 = EtadSym1 a0123456789876543210-    type LiftMaybeSym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =-        LiftMaybe a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (LiftMaybeSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) LiftMaybeSym1KindInference) ())-    data LiftMaybeSym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) (Maybe a0123456789876543210) (Maybe b0123456789876543210)-      where-        LiftMaybeSym1KindInference :: forall a0123456789876543210-                                             a0123456789876543210-                                             arg. SameKind (Apply (LiftMaybeSym1 a0123456789876543210) arg) (LiftMaybeSym2 a0123456789876543210 arg) =>-                                      LiftMaybeSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (LiftMaybeSym1 a0123456789876543210) a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings LiftMaybeSym0 where-      suppressUnusedWarnings = snd (((,) LiftMaybeSym0KindInference) ())-    data LiftMaybeSym0 :: forall a0123456789876543210-                                 b0123456789876543210.-                          (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) (Maybe a0123456789876543210) (Maybe b0123456789876543210))-      where-        LiftMaybeSym0KindInference :: forall a0123456789876543210-                                             arg. SameKind (Apply LiftMaybeSym0 arg) (LiftMaybeSym1 arg) =>-                                      LiftMaybeSym0 a0123456789876543210-    type instance Apply LiftMaybeSym0 a0123456789876543210 = LiftMaybeSym1 a0123456789876543210-    type MapSym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: [a0123456789876543210]) =-        Map a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (MapSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MapSym1KindInference) ())-    data MapSym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) [a0123456789876543210] [b0123456789876543210]-      where-        MapSym1KindInference :: forall a0123456789876543210-                                       a0123456789876543210-                                       arg. SameKind (Apply (MapSym1 a0123456789876543210) arg) (MapSym2 a0123456789876543210 arg) =>-                                MapSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (MapSym1 a0123456789876543210) a0123456789876543210 = Map a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings MapSym0 where-      suppressUnusedWarnings = snd (((,) MapSym0KindInference) ())-    data MapSym0 :: forall a0123456789876543210 b0123456789876543210.-                    (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) [a0123456789876543210] [b0123456789876543210])-      where-        MapSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply MapSym0 arg) (MapSym1 arg) =>-                                MapSym0 a0123456789876543210-    type instance Apply MapSym0 a0123456789876543210 = MapSym1 a0123456789876543210-    type family Foo (a :: (~>) ((~>) a b) ((~>) a b)) (a :: (~>) a b) (a :: a) :: b where-      Foo f g a = Apply (Apply f g) a-    type family ZipWith (a :: (~>) a ((~>) b c)) (a :: [a]) (a :: [b]) :: [c] where-      ZipWith f ( '(:) x xs) ( '(:) y ys) = Apply (Apply (:@#@$) (Apply (Apply f x) y)) (Apply (Apply (Apply ZipWithSym0 f) xs) ys)-      ZipWith _ '[] '[] = '[]-      ZipWith _ ( '(:) _ _) '[] = '[]-      ZipWith _ '[] ( '(:) _ _) = '[]-    type family Splunge (a :: [Nat]) (a :: [Bool]) :: [Nat] where-      Splunge ns bs = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789876543210Sym0 ns) bs)) ns) bs-    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-    type family LiftMaybe (a :: (~>) a b) (a :: Maybe a) :: Maybe b where-      LiftMaybe f ( 'Just x) = Apply JustSym0 (Apply f x)-      LiftMaybe _  'Nothing = NothingSym0-    type family Map (a :: (~>) a b) (a :: [a]) :: [b] where-      Map _ '[] = '[]-      Map f ( '(:) h t) = Apply (Apply (:@#@$) (Apply f h)) (Apply (Apply MapSym0 f) t)-    sFoo ::-      forall a-             b-             (t :: (~>) ((~>) a b) ((~>) a b))-             (t :: (~>) a b)-             (t :: a).-      Sing t-      -> Sing t-         -> Sing t -> Sing (Apply (Apply (Apply FooSym0 t) t) t :: b)-    sZipWith ::-      forall a b c (t :: (~>) a ((~>) b c)) (t :: [a]) (t :: [b]).-      Sing t-      -> Sing t-         -> Sing t -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c])-    sSplunge ::-      forall (t :: [Nat]) (t :: [Bool]).-      Sing t -> Sing t -> Sing (Apply (Apply SplungeSym0 t) t :: [Nat])-    sEtad ::-      forall (t :: [Nat]) (t :: [Bool]).-      Sing t -> Sing t -> Sing (Apply (Apply EtadSym0 t) t :: [Nat])-    sLiftMaybe ::-      forall a b (t :: (~>) a b) (t :: Maybe a).-      Sing t-      -> Sing t -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b)-    sMap ::-      forall a b (t :: (~>) a b) (t :: [a]).-      Sing t -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b])-    sFoo (sF :: Sing f) (sG :: Sing g) (sA :: Sing a)-      = (applySing ((applySing sF) sG)) sA-    sZipWith-      (sF :: Sing f)-      (SCons (sX :: Sing x) (sXs :: Sing xs))-      (SCons (sY :: Sing y) (sYs :: Sing ys))-      = (applySing-           ((applySing ((singFun2 @(:@#@$)) SCons))-              ((applySing ((applySing sF) sX)) sY)))-          ((applySing-              ((applySing ((applySing ((singFun3 @ZipWithSym0) sZipWith)) sF))-                 sXs))-             sYs)-    sZipWith _ SNil SNil = SNil-    sZipWith _ (SCons _ _) SNil = SNil-    sZipWith _ SNil (SCons _ _) = SNil-    sSplunge (sNs :: Sing ns) (sBs :: Sing bs)-      = (applySing-           ((applySing-               ((applySing ((singFun3 @ZipWithSym0) sZipWith))-                  ((singFun2 @(Apply (Apply Lambda_0123456789876543210Sym0 ns) bs))-                     (\ sN sB-                        -> case ((,) sN) sB of {-                             (,) (_ :: Sing n) (_ :: Sing b)-                               -> (case sB of-                                     STrue-                                       -> (applySing ((singFun1 @SuccSym0) SSucc))-                                            ((applySing ((singFun1 @SuccSym0) SSucc)) sN)-                                     SFalse -> sN) ::-                                    Sing (Case_0123456789876543210 ns bs n b b) }))))-              sNs))-          sBs-    sEtad-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((applySing-               ((applySing ((singFun3 @ZipWithSym0) sZipWith))-                  ((singFun2-                      @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210))-                     (\ sN sB-                        -> case ((,) sN) sB of {-                             (,) (_ :: Sing n) (_ :: Sing b)-                               -> (case sB of-                                     STrue-                                       -> (applySing ((singFun1 @SuccSym0) SSucc))-                                            ((applySing ((singFun1 @SuccSym0) SSucc)) sN)-                                     SFalse -> sN) ::-                                    Sing (Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 b) }))))-              sA_0123456789876543210))-          sA_0123456789876543210-    sLiftMaybe (sF :: Sing f) (SJust (sX :: Sing x))-      = (applySing ((singFun1 @JustSym0) SJust)) ((applySing sF) sX)-    sLiftMaybe _ SNothing = SNothing-    sMap _ SNil = SNil-    sMap (sF :: Sing f) (SCons (sH :: Sing h) (sT :: Sing t))-      = (applySing-           ((applySing ((singFun2 @(:@#@$)) SCons)) ((applySing sF) sH)))-          ((applySing ((applySing ((singFun2 @MapSym0) sMap)) sF)) sT)-    instance SingI (FooSym0 :: (~>) ((~>) ((~>) a b) ((~>) a b)) ((~>) ((~>) a b) ((~>) a b))) where-      sing = (singFun3 @FooSym0) sFoo-    instance SingI d =>-             SingI (FooSym1 (d :: (~>) ((~>) a b) ((~>) a b)) :: (~>) ((~>) a b) ((~>) a b)) where-      sing-        = (singFun2 @(FooSym1 (d :: (~>) ((~>) a b) ((~>) a b))))-            (sFoo (sing @d))-    instance (SingI d, SingI d) =>-             SingI (FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b) :: (~>) a b) where-      sing-        = (singFun1-             @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b)))-            ((sFoo (sing @d)) (sing @d))-    instance SingI (ZipWithSym0 :: (~>) ((~>) a ((~>) b c)) ((~>) [a] ((~>) [b] [c]))) where-      sing = (singFun3 @ZipWithSym0) sZipWith-    instance SingI d =>-             SingI (ZipWithSym1 (d :: (~>) a ((~>) b c)) :: (~>) [a] ((~>) [b] [c])) where-      sing-        = (singFun2 @(ZipWithSym1 (d :: (~>) a ((~>) b c))))-            (sZipWith (sing @d))-    instance (SingI d, SingI d) =>-             SingI (ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]) :: (~>) [b] [c]) where-      sing-        = (singFun1 @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a])))-            ((sZipWith (sing @d)) (sing @d))-    instance SingI (SplungeSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])) where-      sing = (singFun2 @SplungeSym0) sSplunge-    instance SingI d =>-             SingI (SplungeSym1 (d :: [Nat]) :: (~>) [Bool] [Nat]) where-      sing = (singFun1 @(SplungeSym1 (d :: [Nat]))) (sSplunge (sing @d))-    instance SingI (EtadSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])) where-      sing = (singFun2 @EtadSym0) sEtad-    instance SingI d =>-             SingI (EtadSym1 (d :: [Nat]) :: (~>) [Bool] [Nat]) where-      sing = (singFun1 @(EtadSym1 (d :: [Nat]))) (sEtad (sing @d))-    instance SingI (LiftMaybeSym0 :: (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b))) where-      sing = (singFun2 @LiftMaybeSym0) sLiftMaybe-    instance SingI d =>-             SingI (LiftMaybeSym1 (d :: (~>) a b) :: (~>) (Maybe a) (Maybe b)) where-      sing-        = (singFun1 @(LiftMaybeSym1 (d :: (~>) a b)))-            (sLiftMaybe (sing @d))-    instance SingI (MapSym0 :: (~>) ((~>) a b) ((~>) [a] [b])) where-      sing = (singFun2 @MapSym0) sMap-    instance SingI d =>-             SingI (MapSym1 (d :: (~>) a b) :: (~>) [a] [b]) where-      sing = (singFun1 @(MapSym1 (d :: (~>) a b))) (sMap (sing @d))-    data instance Sing :: Either a b -> GHC.Types.Type-      where-        SLeft :: forall a (n :: a). (Sing (n :: a)) -> Sing (Left n)-        SRight :: forall b (n :: b). (Sing (n :: b)) -> Sing (Right n)-    type SEither = (Sing :: Either a b -> GHC.Types.Type)-    instance (SingKind a, SingKind b) => SingKind (Either a b) where-      type Demote (Either a b) = Either (Demote a) (Demote b)-      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) }-      toSing (Right (b :: Demote b))-        = case toSing b :: SomeSing b of {-            SomeSing c -> SomeSing (SRight c) }-    instance SingI n => SingI (Left (n :: a)) where-      sing = SLeft sing-    instance SingI (LeftSym0 :: (~>) a (Either a b)) where-      sing = (singFun1 @LeftSym0) SLeft-    instance SingI (TyCon1 Left :: (~>) a (Either a b)) where-      sing = (singFun1 @(TyCon1 Left)) SLeft-    instance SingI n => SingI (Right (n :: b)) where-      sing = SRight sing-    instance SingI (RightSym0 :: (~>) b (Either a b)) where-      sing = (singFun1 @RightSym0) SRight-    instance SingI (TyCon1 Right :: (~>) b (Either a b)) where-      sing = (singFun1 @(TyCon1 Right)) SRight
+ tests/compile-and-dump/Singletons/HigherOrder.ghc88.template view
@@ -0,0 +1,477 @@+Singletons/HigherOrder.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| map :: (a -> b) -> [a] -> [b]+          map _ [] = []+          map f (h : t) = (f h) : (map f t)+          liftMaybe :: (a -> b) -> Maybe a -> Maybe b+          liftMaybe f (Just x) = Just (f x)+          liftMaybe _ Nothing = Nothing+          zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]+          zipWith f (x : xs) (y : ys) = f x y : zipWith f xs ys+          zipWith _ [] [] = []+          zipWith _ (_ : _) [] = []+          zipWith _ [] (_ : _) = []+          foo :: ((a -> b) -> a -> b) -> (a -> b) -> a -> b+          foo f g a = f g a+          splunge :: [Nat] -> [Bool] -> [Nat]+          splunge ns bs+            = zipWith (\ n b -> if b then Succ (Succ n) else n) ns bs+          etad :: [Nat] -> [Bool] -> [Nat]+          etad = zipWith (\ n b -> if b then Succ (Succ n) else n)+          +          data Either a b = Left a | Right b |]+  ======>+    data Either a b = Left a | Right b+    map :: (a -> b) -> [a] -> [b]+    map _ [] = []+    map f (h : t) = (f h : (map f) t)+    liftMaybe :: (a -> b) -> Maybe a -> Maybe b+    liftMaybe f (Just x) = Just (f x)+    liftMaybe _ Nothing = Nothing+    zipWith :: (a -> b -> c) -> [a] -> [b] -> [c]+    zipWith f (x : xs) (y : ys) = ((f x) y : ((zipWith f) xs) ys)+    zipWith _ [] [] = []+    zipWith _ (_ : _) [] = []+    zipWith _ [] (_ : _) = []+    foo :: ((a -> b) -> a -> b) -> (a -> b) -> a -> b+    foo f g a = (f g) a+    splunge :: [Nat] -> [Bool] -> [Nat]+    splunge ns bs+      = ((zipWith (\ n b -> if b then Succ (Succ n) else n)) ns) bs+    etad :: [Nat] -> [Bool] -> [Nat]+    etad = zipWith (\ n b -> if b then Succ (Succ n) else n)+    type LeftSym1 (t0123456789876543210 :: a0123456789876543210) =+        Left t0123456789876543210+    instance SuppressUnusedWarnings LeftSym0 where+      suppressUnusedWarnings = snd (((,) LeftSym0KindInference) ())+    data LeftSym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 (Either a0123456789876543210 b0123456789876543210)+      where+        LeftSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply LeftSym0 arg) (LeftSym1 arg) =>+                                 LeftSym0 t0123456789876543210+    type instance Apply LeftSym0 t0123456789876543210 = Left t0123456789876543210+    type RightSym1 (t0123456789876543210 :: b0123456789876543210) =+        Right t0123456789876543210+    instance SuppressUnusedWarnings RightSym0 where+      suppressUnusedWarnings = snd (((,) RightSym0KindInference) ())+    data RightSym0 :: forall b0123456789876543210 a0123456789876543210.+                      (~>) b0123456789876543210 (Either a0123456789876543210 b0123456789876543210)+      where+        RightSym0KindInference :: forall t0123456789876543210+                                         arg. SameKind (Apply RightSym0 arg) (RightSym1 arg) =>+                                  RightSym0 t0123456789876543210+    type instance Apply RightSym0 t0123456789876543210 = Right t0123456789876543210+    type family Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 t where+      Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 'True = Apply SuccSym0 (Apply SuccSym0 n)+      Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 'False = n+    type family Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t where+      Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n b = Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 b+    type Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym3 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall a_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210+    type family Case_0123456789876543210 n b ns bs t where+      Case_0123456789876543210 n b ns bs 'True = Apply SuccSym0 (Apply SuccSym0 n)+      Case_0123456789876543210 n b ns bs 'False = n+    type family Lambda_0123456789876543210 ns bs t t where+      Lambda_0123456789876543210 ns bs n b = Case_0123456789876543210 n b ns bs b+    type Lambda_0123456789876543210Sym4 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 t0123456789876543210 bs0123456789876543210 ns0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall ns0123456789876543210+                                                              bs0123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym4 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym3 t0123456789876543210 bs0123456789876543210 ns0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 bs0123456789876543210 ns0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 bs0123456789876543210 ns0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall ns0123456789876543210+                                                              bs0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210) arg) (Lambda_0123456789876543210Sym3 ns0123456789876543210 bs0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 ns0123456789876543210 bs0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 bs0123456789876543210 ns0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym3 bs0123456789876543210 ns0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 ns0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 ns0123456789876543210 bs0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall ns0123456789876543210+                                                              bs0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 ns0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall ns0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 ns0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 ns0123456789876543210 = Lambda_0123456789876543210Sym1 ns0123456789876543210+    type EtadSym2 (a0123456789876543210 :: [Nat]) (a0123456789876543210 :: [Bool]) =+        Etad a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (EtadSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) EtadSym1KindInference) ())+    data EtadSym1 (a0123456789876543210 :: [Nat]) :: (~>) [Bool] [Nat]+      where+        EtadSym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (EtadSym1 a0123456789876543210) arg) (EtadSym2 a0123456789876543210 arg) =>+                                 EtadSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (EtadSym1 a0123456789876543210) a0123456789876543210 = Etad a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings EtadSym0 where+      suppressUnusedWarnings = snd (((,) EtadSym0KindInference) ())+    data EtadSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])+      where+        EtadSym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply EtadSym0 arg) (EtadSym1 arg) =>+                                 EtadSym0 a0123456789876543210+    type instance Apply EtadSym0 a0123456789876543210 = EtadSym1 a0123456789876543210+    type SplungeSym2 (a0123456789876543210 :: [Nat]) (a0123456789876543210 :: [Bool]) =+        Splunge a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (SplungeSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) SplungeSym1KindInference) ())+    data SplungeSym1 (a0123456789876543210 :: [Nat]) :: (~>) [Bool] [Nat]+      where+        SplungeSym1KindInference :: forall a0123456789876543210+                                           a0123456789876543210+                                           arg. SameKind (Apply (SplungeSym1 a0123456789876543210) arg) (SplungeSym2 a0123456789876543210 arg) =>+                                    SplungeSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (SplungeSym1 a0123456789876543210) a0123456789876543210 = Splunge a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings SplungeSym0 where+      suppressUnusedWarnings = snd (((,) SplungeSym0KindInference) ())+    data SplungeSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])+      where+        SplungeSym0KindInference :: forall a0123456789876543210+                                           arg. SameKind (Apply SplungeSym0 arg) (SplungeSym1 arg) =>+                                    SplungeSym0 a0123456789876543210+    type instance Apply SplungeSym0 a0123456789876543210 = SplungeSym1 a0123456789876543210+    type FooSym3 (a0123456789876543210 :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: a0123456789876543210) =+        Foo a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (FooSym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FooSym2KindInference) ())+    data FooSym2 (a0123456789876543210 :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) a0123456789876543210 b0123456789876543210+      where+        FooSym2KindInference :: forall a0123456789876543210+                                       a0123456789876543210+                                       a0123456789876543210+                                       arg. 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+    instance SuppressUnusedWarnings (FooSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FooSym1KindInference) ())+    data FooSym1 (a0123456789876543210 :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)) :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)+      where+        FooSym1KindInference :: forall a0123456789876543210+                                       a0123456789876543210+                                       arg. SameKind (Apply (FooSym1 a0123456789876543210) arg) (FooSym2 a0123456789876543210 arg) =>+                                FooSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (FooSym1 a0123456789876543210) a0123456789876543210 = FooSym2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: forall a0123456789876543210 b0123456789876543210.+                    (~>) ((~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)) ((~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210))+      where+        FooSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 a0123456789876543210+    type instance Apply FooSym0 a0123456789876543210 = FooSym1 a0123456789876543210+    type ZipWithSym3 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 c0123456789876543210)) (a0123456789876543210 :: [a0123456789876543210]) (a0123456789876543210 :: [b0123456789876543210]) =+        ZipWith a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ZipWithSym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ZipWithSym2KindInference) ())+    data ZipWithSym2 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 c0123456789876543210)) (a0123456789876543210 :: [a0123456789876543210]) :: (~>) [b0123456789876543210] [c0123456789876543210]+      where+        ZipWithSym2KindInference :: forall a0123456789876543210+                                           a0123456789876543210+                                           a0123456789876543210+                                           arg. 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+    instance SuppressUnusedWarnings (ZipWithSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ZipWithSym1KindInference) ())+    data ZipWithSym1 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 c0123456789876543210)) :: (~>) [a0123456789876543210] ((~>) [b0123456789876543210] [c0123456789876543210])+      where+        ZipWithSym1KindInference :: forall a0123456789876543210+                                           a0123456789876543210+                                           arg. SameKind (Apply (ZipWithSym1 a0123456789876543210) arg) (ZipWithSym2 a0123456789876543210 arg) =>+                                    ZipWithSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (ZipWithSym1 a0123456789876543210) a0123456789876543210 = ZipWithSym2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ZipWithSym0 where+      suppressUnusedWarnings = snd (((,) ZipWithSym0KindInference) ())+    data ZipWithSym0 :: forall a0123456789876543210+                               b0123456789876543210+                               c0123456789876543210.+                        (~>) ((~>) a0123456789876543210 ((~>) b0123456789876543210 c0123456789876543210)) ((~>) [a0123456789876543210] ((~>) [b0123456789876543210] [c0123456789876543210]))+      where+        ZipWithSym0KindInference :: forall a0123456789876543210+                                           arg. SameKind (Apply ZipWithSym0 arg) (ZipWithSym1 arg) =>+                                    ZipWithSym0 a0123456789876543210+    type instance Apply ZipWithSym0 a0123456789876543210 = ZipWithSym1 a0123456789876543210+    type LiftMaybeSym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =+        LiftMaybe a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (LiftMaybeSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) LiftMaybeSym1KindInference) ())+    data LiftMaybeSym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) (Maybe a0123456789876543210) (Maybe b0123456789876543210)+      where+        LiftMaybeSym1KindInference :: forall a0123456789876543210+                                             a0123456789876543210+                                             arg. SameKind (Apply (LiftMaybeSym1 a0123456789876543210) arg) (LiftMaybeSym2 a0123456789876543210 arg) =>+                                      LiftMaybeSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (LiftMaybeSym1 a0123456789876543210) a0123456789876543210 = LiftMaybe a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings LiftMaybeSym0 where+      suppressUnusedWarnings = snd (((,) LiftMaybeSym0KindInference) ())+    data LiftMaybeSym0 :: forall a0123456789876543210+                                 b0123456789876543210.+                          (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) (Maybe a0123456789876543210) (Maybe b0123456789876543210))+      where+        LiftMaybeSym0KindInference :: forall a0123456789876543210+                                             arg. SameKind (Apply LiftMaybeSym0 arg) (LiftMaybeSym1 arg) =>+                                      LiftMaybeSym0 a0123456789876543210+    type instance Apply LiftMaybeSym0 a0123456789876543210 = LiftMaybeSym1 a0123456789876543210+    type MapSym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: [a0123456789876543210]) =+        Map a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (MapSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MapSym1KindInference) ())+    data MapSym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) [a0123456789876543210] [b0123456789876543210]+      where+        MapSym1KindInference :: forall a0123456789876543210+                                       a0123456789876543210+                                       arg. SameKind (Apply (MapSym1 a0123456789876543210) arg) (MapSym2 a0123456789876543210 arg) =>+                                MapSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (MapSym1 a0123456789876543210) a0123456789876543210 = Map a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings MapSym0 where+      suppressUnusedWarnings = snd (((,) MapSym0KindInference) ())+    data MapSym0 :: forall a0123456789876543210 b0123456789876543210.+                    (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) [a0123456789876543210] [b0123456789876543210])+      where+        MapSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply MapSym0 arg) (MapSym1 arg) =>+                                MapSym0 a0123456789876543210+    type instance Apply MapSym0 a0123456789876543210 = MapSym1 a0123456789876543210+    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+    type family Splunge (a :: [Nat]) (a :: [Bool]) :: [Nat] where+      Splunge ns bs = Apply (Apply (Apply ZipWithSym0 (Apply (Apply Lambda_0123456789876543210Sym0 ns) bs)) ns) bs+    type family Foo (a :: (~>) ((~>) a b) ((~>) a b)) (a :: (~>) a b) (a :: a) :: b where+      Foo f g a = Apply (Apply f g) a+    type family ZipWith (a :: (~>) a ((~>) b c)) (a :: [a]) (a :: [b]) :: [c] where+      ZipWith f ('(:) x xs) ('(:) y ys) = Apply (Apply (:@#@$) (Apply (Apply f x) y)) (Apply (Apply (Apply ZipWithSym0 f) xs) ys)+      ZipWith _ '[] '[] = '[]+      ZipWith _ ('(:) _ _) '[] = '[]+      ZipWith _ '[] ('(:) _ _) = '[]+    type family LiftMaybe (a :: (~>) a b) (a :: Maybe a) :: Maybe b where+      LiftMaybe f ('Just x) = Apply JustSym0 (Apply f x)+      LiftMaybe _ 'Nothing = NothingSym0+    type family Map (a :: (~>) a b) (a :: [a]) :: [b] where+      Map _ '[] = '[]+      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])+    sSplunge ::+      forall (t :: [Nat]) (t :: [Bool]).+      Sing t -> Sing t -> Sing (Apply (Apply SplungeSym0 t) t :: [Nat])+    sFoo ::+      forall a+             b+             (t :: (~>) ((~>) a b) ((~>) a b))+             (t :: (~>) a b)+             (t :: a).+      Sing t+      -> Sing t+         -> Sing t -> Sing (Apply (Apply (Apply FooSym0 t) t) t :: b)+    sZipWith ::+      forall a b c (t :: (~>) a ((~>) b c)) (t :: [a]) (t :: [b]).+      Sing t+      -> Sing t+         -> Sing t -> Sing (Apply (Apply (Apply ZipWithSym0 t) t) t :: [c])+    sLiftMaybe ::+      forall a b (t :: (~>) a b) (t :: Maybe a).+      Sing t+      -> Sing t -> Sing (Apply (Apply LiftMaybeSym0 t) t :: Maybe b)+    sMap ::+      forall a b (t :: (~>) a b) (t :: [a]).+      Sing t -> Sing t -> Sing (Apply (Apply MapSym0 t) t :: [b])+    sEtad+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing+           ((applySing+               ((applySing ((singFun3 @ZipWithSym0) sZipWith))+                  ((singFun2+                      @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210))+                     (\ sN sB+                        -> case ((,) sN) sB of {+                             (,) (_ :: Sing n) (_ :: Sing b)+                               -> (id+                                     @(Sing (Case_0123456789876543210 n b a_0123456789876543210 a_0123456789876543210 b)))+                                    (case sB of+                                       STrue+                                         -> (applySing ((singFun1 @SuccSym0) SSucc))+                                              ((applySing ((singFun1 @SuccSym0) SSucc)) sN)+                                       SFalse -> sN) }))))+              sA_0123456789876543210))+          sA_0123456789876543210+    sSplunge (sNs :: Sing ns) (sBs :: Sing bs)+      = (applySing+           ((applySing+               ((applySing ((singFun3 @ZipWithSym0) sZipWith))+                  ((singFun2 @(Apply (Apply Lambda_0123456789876543210Sym0 ns) bs))+                     (\ sN sB+                        -> case ((,) sN) sB of {+                             (,) (_ :: Sing n) (_ :: Sing b)+                               -> (id @(Sing (Case_0123456789876543210 n b ns bs b)))+                                    (case sB of+                                       STrue+                                         -> (applySing ((singFun1 @SuccSym0) SSucc))+                                              ((applySing ((singFun1 @SuccSym0) SSucc)) sN)+                                       SFalse -> sN) }))))+              sNs))+          sBs+    sFoo (sF :: Sing f) (sG :: Sing g) (sA :: Sing a)+      = (applySing ((applySing sF) sG)) sA+    sZipWith+      (sF :: Sing f)+      (SCons (sX :: Sing x) (sXs :: Sing xs))+      (SCons (sY :: Sing y) (sYs :: Sing ys))+      = (applySing+           ((applySing ((singFun2 @(:@#@$)) SCons))+              ((applySing ((applySing sF) sX)) sY)))+          ((applySing+              ((applySing ((applySing ((singFun3 @ZipWithSym0) sZipWith)) sF))+                 sXs))+             sYs)+    sZipWith _ SNil SNil = SNil+    sZipWith _ (SCons _ _) SNil = SNil+    sZipWith _ SNil (SCons _ _) = SNil+    sLiftMaybe (sF :: Sing f) (SJust (sX :: Sing x))+      = (applySing ((singFun1 @JustSym0) SJust)) ((applySing sF) sX)+    sLiftMaybe _ SNothing = SNothing+    sMap _ SNil = SNil+    sMap (sF :: Sing f) (SCons (sH :: Sing h) (sT :: Sing t))+      = (applySing+           ((applySing ((singFun2 @(:@#@$)) SCons)) ((applySing sF) sH)))+          ((applySing ((applySing ((singFun2 @MapSym0) sMap)) sF)) sT)+    instance SingI (EtadSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])) where+      sing = (singFun2 @EtadSym0) sEtad+    instance SingI d =>+             SingI (EtadSym1 (d :: [Nat]) :: (~>) [Bool] [Nat]) where+      sing = (singFun1 @(EtadSym1 (d :: [Nat]))) (sEtad (sing @d))+    instance SingI (SplungeSym0 :: (~>) [Nat] ((~>) [Bool] [Nat])) where+      sing = (singFun2 @SplungeSym0) sSplunge+    instance SingI d =>+             SingI (SplungeSym1 (d :: [Nat]) :: (~>) [Bool] [Nat]) where+      sing = (singFun1 @(SplungeSym1 (d :: [Nat]))) (sSplunge (sing @d))+    instance SingI (FooSym0 :: (~>) ((~>) ((~>) a b) ((~>) a b)) ((~>) ((~>) a b) ((~>) a b))) where+      sing = (singFun3 @FooSym0) sFoo+    instance SingI d =>+             SingI (FooSym1 (d :: (~>) ((~>) a b) ((~>) a b)) :: (~>) ((~>) a b) ((~>) a b)) where+      sing+        = (singFun2 @(FooSym1 (d :: (~>) ((~>) a b) ((~>) a b))))+            (sFoo (sing @d))+    instance (SingI d, SingI d) =>+             SingI (FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b) :: (~>) a b) where+      sing+        = (singFun1+             @(FooSym2 (d :: (~>) ((~>) a b) ((~>) a b)) (d :: (~>) a b)))+            ((sFoo (sing @d)) (sing @d))+    instance SingI (ZipWithSym0 :: (~>) ((~>) a ((~>) b c)) ((~>) [a] ((~>) [b] [c]))) where+      sing = (singFun3 @ZipWithSym0) sZipWith+    instance SingI d =>+             SingI (ZipWithSym1 (d :: (~>) a ((~>) b c)) :: (~>) [a] ((~>) [b] [c])) where+      sing+        = (singFun2 @(ZipWithSym1 (d :: (~>) a ((~>) b c))))+            (sZipWith (sing @d))+    instance (SingI d, SingI d) =>+             SingI (ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a]) :: (~>) [b] [c]) where+      sing+        = (singFun1 @(ZipWithSym2 (d :: (~>) a ((~>) b c)) (d :: [a])))+            ((sZipWith (sing @d)) (sing @d))+    instance SingI (LiftMaybeSym0 :: (~>) ((~>) a b) ((~>) (Maybe a) (Maybe b))) where+      sing = (singFun2 @LiftMaybeSym0) sLiftMaybe+    instance SingI d =>+             SingI (LiftMaybeSym1 (d :: (~>) a b) :: (~>) (Maybe a) (Maybe b)) where+      sing+        = (singFun1 @(LiftMaybeSym1 (d :: (~>) a b)))+            (sLiftMaybe (sing @d))+    instance SingI (MapSym0 :: (~>) ((~>) a b) ((~>) [a] [b])) where+      sing = (singFun2 @MapSym0) sMap+    instance SingI d =>+             SingI (MapSym1 (d :: (~>) a b) :: (~>) [a] [b]) where+      sing = (singFun1 @(MapSym1 (d :: (~>) a b))) (sMap (sing @d))+    data SEither :: forall a b. Either a b -> GHC.Types.Type+      where+        SLeft :: forall a (n :: a). (Sing (n :: a)) -> SEither (Left n)+        SRight :: forall b (n :: b). (Sing (n :: b)) -> SEither (Right n)+    type instance Sing @(Either a b) = SEither+    instance (SingKind a, SingKind b) => SingKind (Either a b) where+      type Demote (Either a b) = Either (Demote a) (Demote b)+      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) }+      toSing (Right (b :: Demote b))+        = case toSing b :: SomeSing b of {+            SomeSing c -> SomeSing (SRight c) }+    instance SingI n => SingI (Left (n :: a)) where+      sing = SLeft sing+    instance SingI (LeftSym0 :: (~>) a (Either a b)) where+      sing = (singFun1 @LeftSym0) SLeft+    instance SingI n => SingI (Right (n :: b)) where+      sing = SRight sing+    instance SingI (RightSym0 :: (~>) b (Either a b)) where+      sing = (singFun1 @RightSym0) SRight
− tests/compile-and-dump/Singletons/LambdaCase.ghc86.template 
@@ -1,252 +0,0 @@-Singletons/LambdaCase.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo1 :: a -> Maybe a -> a-          foo1 d x-            = (\case-                 Just y -> y-                 Nothing -> d)-                x-          foo2 :: a -> Maybe a -> a-          foo2 d _-            = (\case-                 Just y -> y-                 Nothing -> d)-                (Just d)-          foo3 :: a -> b -> a-          foo3 a b = (\case (p, _) -> p) (a, b) |]-  ======>-    foo1 :: a -> Maybe a -> a-    foo1 d x-      = (\case-           Just y -> y-           Nothing -> d)-          x-    foo2 :: a -> Maybe a -> a-    foo2 d _-      = (\case-           Just y -> y-           Nothing -> d)-          (Just d)-    foo3 :: a -> b -> a-    foo3 a b = (\case (p, _) -> p) (a, b)-    type family Case_0123456789876543210 a b x_0123456789876543210 t where-      Case_0123456789876543210 a b x_0123456789876543210 '(p, _) = p-    type family Lambda_0123456789876543210 a b t where-      Lambda_0123456789876543210 a b x_0123456789876543210 = Case_0123456789876543210 a b x_0123456789876543210 x_0123456789876543210-    type Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                              b0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 b0123456789876543210 a0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                              b0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 a0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210-    type family Case_0123456789876543210 d x_0123456789876543210 t where-      Case_0123456789876543210 d x_0123456789876543210 ( 'Just y) = y-      Case_0123456789876543210 d x_0123456789876543210  'Nothing = d-    type family Lambda_0123456789876543210 d t where-      Lambda_0123456789876543210 d x_0123456789876543210 = Case_0123456789876543210 d x_0123456789876543210 x_0123456789876543210-    type Lambda_0123456789876543210Sym2 d0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 d0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 d0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 d0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall d0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 d0123456789876543210) arg) (Lambda_0123456789876543210Sym2 d0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym1 d0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym1 d0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 d0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 d0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall d0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 d0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 d0123456789876543210 = Lambda_0123456789876543210Sym1 d0123456789876543210-    type family Case_0123456789876543210 d x x_0123456789876543210 t where-      Case_0123456789876543210 d x x_0123456789876543210 ( 'Just y) = y-      Case_0123456789876543210 d x x_0123456789876543210  'Nothing = d-    type family Lambda_0123456789876543210 d x t where-      Lambda_0123456789876543210 d x x_0123456789876543210 = Case_0123456789876543210 d x x_0123456789876543210 x_0123456789876543210-    type Lambda_0123456789876543210Sym3 d0123456789876543210 x0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 d0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 d0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall d0123456789876543210-                                                              x0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym3 d0123456789876543210 x0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 d0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 d0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 d0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 d0123456789876543210 x0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall d0123456789876543210-                                                              x0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 d0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall d0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 d0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 d0123456789876543210 = Lambda_0123456789876543210Sym1 d0123456789876543210-    type Foo3Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo3 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo3Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo3Sym1KindInference) ())-    data Foo3Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 a0123456789876543210-      where-        Foo3Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo3Sym1 a0123456789876543210) arg) (Foo3Sym2 a0123456789876543210 arg) =>-                                 Foo3Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo3Sym1 a0123456789876543210) a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo3Sym0 where-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())-    data Foo3Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        Foo3Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>-                                 Foo3Sym0 a0123456789876543210-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3Sym1 a0123456789876543210-    type Foo2Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =-        Foo2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())-    data Foo2Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) a0123456789876543210-      where-        Foo2Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>-                                 Foo2Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo2Sym0 where-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())-    data Foo2Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) a0123456789876543210)-      where-        Foo2Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>-                                 Foo2Sym0 a0123456789876543210-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210-    type Foo1Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =-        Foo1 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())-    data Foo1Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) a0123456789876543210-      where-        Foo1Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>-                                 Foo1Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo1Sym0 where-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())-    data Foo1Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) a0123456789876543210)-      where-        Foo1Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>-                                 Foo1Sym0 a0123456789876543210-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210-    type family Foo3 (a :: a) (a :: b) :: a where-      Foo3 a b = Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) (Apply (Apply Tuple2Sym0 a) b)-    type family Foo2 (a :: a) (a :: Maybe a) :: a where-      Foo2 d _ = Apply (Apply Lambda_0123456789876543210Sym0 d) (Apply JustSym0 d)-    type family Foo1 (a :: a) (a :: Maybe a) :: a where-      Foo1 d x = Apply (Apply (Apply Lambda_0123456789876543210Sym0 d) x) x-    sFoo3 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a)-    sFoo2 ::-      forall a (t :: a) (t :: Maybe a).-      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)-    sFoo1 ::-      forall a (t :: a) (t :: Maybe a).-      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)-    sFoo3 (sA :: Sing a) (sB :: Sing b)-      = (applySing-           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 a) b))-              (\ sX_0123456789876543210-                 -> case sX_0123456789876543210 of {-                      (_ :: Sing x_0123456789876543210)-                        -> (case sX_0123456789876543210 of {-                              STuple2 (sP :: Sing p) _ -> sP }) ::-                             Sing (Case_0123456789876543210 a b x_0123456789876543210 x_0123456789876543210) })))-          ((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)-                        -> (case sX_0123456789876543210 of-                              SJust (sY :: Sing y) -> sY-                              SNothing -> sD) ::-                             Sing (Case_0123456789876543210 d x_0123456789876543210 x_0123456789876543210) })))-          ((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)-                        -> (case sX_0123456789876543210 of-                              SJust (sY :: Sing y) -> sY-                              SNothing -> sD) ::-                             Sing (Case_0123456789876543210 d x x_0123456789876543210 x_0123456789876543210) })))-          sX-    instance SingI (Foo3Sym0 :: (~>) a ((~>) b a)) where-      sing = (singFun2 @Foo3Sym0) sFoo3-    instance SingI d => SingI (Foo3Sym1 (d :: a) :: (~>) b a) where-      sing = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 (sing @d))-    instance SingI (Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)) where-      sing = (singFun2 @Foo2Sym0) sFoo2-    instance SingI d =>-             SingI (Foo2Sym1 (d :: a) :: (~>) (Maybe a) a) where-      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))-    instance SingI (Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)) where-      sing = (singFun2 @Foo1Sym0) sFoo1-    instance SingI d =>-             SingI (Foo1Sym1 (d :: a) :: (~>) (Maybe a) a) where-      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))
+ tests/compile-and-dump/Singletons/LambdaCase.ghc88.template view
@@ -0,0 +1,255 @@+Singletons/LambdaCase.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo1 :: a -> Maybe a -> a+          foo1 d x+            = (\case+                 Just y -> y+                 Nothing -> d)+                x+          foo2 :: a -> Maybe a -> a+          foo2 d _+            = (\case+                 Just y -> y+                 Nothing -> d)+                (Just d)+          foo3 :: a -> b -> a+          foo3 a b = (\case (p, _) -> p) (a, b) |]+  ======>+    foo1 :: a -> Maybe a -> a+    foo1 d x+      = (\case+           Just y -> y+           Nothing -> d)+          x+    foo2 :: a -> Maybe a -> a+    foo2 d _+      = (\case+           Just y -> y+           Nothing -> d)+          (Just d)+    foo3 :: a -> b -> a+    foo3 a b = (\case (p, _) -> p) (a, b)+    type family Case_0123456789876543210 x_0123456789876543210 a b t where+      Case_0123456789876543210 x_0123456789876543210 a b '(p, _) = p+    type family Lambda_0123456789876543210 a b t where+      Lambda_0123456789876543210 a b x_0123456789876543210 = Case_0123456789876543210 x_0123456789876543210 a b x_0123456789876543210+    type Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                              b0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 b0123456789876543210 a0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                              b0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 a0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210+    type family Case_0123456789876543210 x_0123456789876543210 d t where+      Case_0123456789876543210 x_0123456789876543210 d ('Just y) = y+      Case_0123456789876543210 x_0123456789876543210 d 'Nothing = d+    type family Lambda_0123456789876543210 d t where+      Lambda_0123456789876543210 d x_0123456789876543210 = Case_0123456789876543210 x_0123456789876543210 d x_0123456789876543210+    type Lambda_0123456789876543210Sym2 d0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 d0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 d0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 d0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall d0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 d0123456789876543210) arg) (Lambda_0123456789876543210Sym2 d0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym1 d0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym1 d0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 d0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 d0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall d0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 d0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 d0123456789876543210 = Lambda_0123456789876543210Sym1 d0123456789876543210+    type family Case_0123456789876543210 x_0123456789876543210 d x t where+      Case_0123456789876543210 x_0123456789876543210 d x ('Just y) = y+      Case_0123456789876543210 x_0123456789876543210 d x 'Nothing = d+    type family Lambda_0123456789876543210 d x t where+      Lambda_0123456789876543210 d x x_0123456789876543210 = Case_0123456789876543210 x_0123456789876543210 d x x_0123456789876543210+    type Lambda_0123456789876543210Sym3 d0123456789876543210 x0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 d0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 d0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall d0123456789876543210+                                                              x0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym3 d0123456789876543210 x0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 d0123456789876543210 x0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 d0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 d0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 d0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 d0123456789876543210 x0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall d0123456789876543210+                                                              x0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 d0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall d0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 d0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 d0123456789876543210 = Lambda_0123456789876543210Sym1 d0123456789876543210+    type Foo3Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo3 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo3Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo3Sym1KindInference) ())+    data Foo3Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 a0123456789876543210+      where+        Foo3Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo3Sym1 a0123456789876543210) arg) (Foo3Sym2 a0123456789876543210 arg) =>+                                 Foo3Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo3Sym1 a0123456789876543210) a0123456789876543210 = Foo3 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo3Sym0 where+      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())+    data Foo3Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        Foo3Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>+                                 Foo3Sym0 a0123456789876543210+    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3Sym1 a0123456789876543210+    type Foo2Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =+        Foo2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())+    data Foo2Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) a0123456789876543210+      where+        Foo2Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>+                                 Foo2Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo2Sym0 where+      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())+    data Foo2Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) a0123456789876543210)+      where+        Foo2Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>+                                 Foo2Sym0 a0123456789876543210+    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210+    type Foo1Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: Maybe a0123456789876543210) =+        Foo1 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())+    data Foo1Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) (Maybe a0123456789876543210) a0123456789876543210+      where+        Foo1Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>+                                 Foo1Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo1Sym0 where+      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())+    data Foo1Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 ((~>) (Maybe a0123456789876543210) a0123456789876543210)+      where+        Foo1Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>+                                 Foo1Sym0 a0123456789876543210+    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210+    type family Foo3 (a :: a) (a :: b) :: a where+      Foo3 a b = Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) (Apply (Apply Tuple2Sym0 a) b)+    type family Foo2 (a :: a) (a :: Maybe a) :: a where+      Foo2 d _ = Apply (Apply Lambda_0123456789876543210Sym0 d) (Apply JustSym0 d)+    type family Foo1 (a :: a) (a :: Maybe a) :: a where+      Foo1 d x = Apply (Apply (Apply Lambda_0123456789876543210Sym0 d) x) x+    sFoo3 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo3Sym0 t) t :: a)+    sFoo2 ::+      forall a (t :: a) (t :: Maybe a).+      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)+    sFoo1 ::+      forall a (t :: a) (t :: Maybe a).+      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)+    sFoo3 (sA :: Sing a) (sB :: Sing b)+      = (applySing+           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 a) b))+              (\ sX_0123456789876543210+                 -> case sX_0123456789876543210 of {+                      (_ :: Sing x_0123456789876543210)+                        -> (id+                              @(Sing (Case_0123456789876543210 x_0123456789876543210 a b x_0123456789876543210)))+                             (case sX_0123456789876543210 of {+                                STuple2 (sP :: Sing p) _ -> sP }) })))+          ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sA)) sB)+    sFoo2 (sD :: Sing d) _+      = (applySing+           ((singFun1 @(Apply Lambda_0123456789876543210Sym0 d))+              (\ sX_0123456789876543210+                 -> case sX_0123456789876543210 of {+                      (_ :: Sing x_0123456789876543210)+                        -> (id+                              @(Sing (Case_0123456789876543210 x_0123456789876543210 d x_0123456789876543210)))+                             (case sX_0123456789876543210 of+                                SJust (sY :: Sing y) -> sY+                                SNothing -> sD) })))+          ((applySing ((singFun1 @JustSym0) SJust)) sD)+    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) })))+          sX+    instance SingI (Foo3Sym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @Foo3Sym0) sFoo3+    instance SingI d => SingI (Foo3Sym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(Foo3Sym1 (d :: a))) (sFoo3 (sing @d))+    instance SingI (Foo2Sym0 :: (~>) a ((~>) (Maybe a) a)) where+      sing = (singFun2 @Foo2Sym0) sFoo2+    instance SingI d =>+             SingI (Foo2Sym1 (d :: a) :: (~>) (Maybe a) a) where+      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))+    instance SingI (Foo1Sym0 :: (~>) a ((~>) (Maybe a) a)) where+      sing = (singFun2 @Foo1Sym0) sFoo1+    instance SingI d =>+             SingI (Foo1Sym1 (d :: a) :: (~>) (Maybe a) a) where+      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))
− tests/compile-and-dump/Singletons/Lambdas.ghc86.template 
@@ -1,830 +0,0 @@-Singletons/Lambdas.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo0 :: a -> b -> a-          foo0 = (\ x y -> x)-          foo1 :: a -> b -> a-          foo1 x = (\ _ -> x)-          foo2 :: a -> b -> a-          foo2 x y = (\ _ -> x) y-          foo3 :: a -> a-          foo3 x = (\ y -> y) x-          foo4 :: a -> b -> c -> a-          foo4 x y z = (\ _ _ -> x) y z-          foo5 :: a -> b -> b-          foo5 x y = (\ x -> x) y-          foo6 :: a -> b -> a-          foo6 a b = (\ x -> \ _ -> x) a b-          foo7 :: a -> b -> b-          foo7 x y = (\ (_, b) -> b) (x, y)-          foo8 :: Foo a b -> a-          foo8 x = (\ (Foo a _) -> a) x-          -          data Foo a b = Foo a b |]-  ======>-    foo0 :: a -> b -> a-    foo0 = \ x y -> x-    foo1 :: a -> b -> a-    foo1 x = \ _ -> x-    foo2 :: a -> b -> a-    foo2 x y = (\ _ -> x) y-    foo3 :: a -> a-    foo3 x = (\ y -> y) x-    foo4 :: a -> b -> c -> a-    foo4 x y z = ((\ _ _ -> x) y) z-    foo5 :: a -> b -> b-    foo5 x y = (\ x -> x) y-    foo6 :: a -> b -> a-    foo6 a b = ((\ x -> \ _ -> x) a) b-    foo7 :: a -> b -> b-    foo7 x y = (\ (_, b) -> b) (x, y)-    data Foo a b = Foo a b-    foo8 :: Foo a b -> a-    foo8 x = (\ (Foo a _) -> a) x-    type FooSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =-        Foo t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (FooSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FooSym1KindInference) ())-    data FooSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                   (~>) b0123456789876543210 (Foo a0123456789876543210 b0123456789876543210)-      where-        FooSym1KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (FooSym1 t0123456789876543210) arg) (FooSym2 t0123456789876543210 arg) =>-                                FooSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (FooSym1 t0123456789876543210) t0123456789876543210 = Foo t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: forall a0123456789876543210 b0123456789876543210.-                    (~>) a0123456789876543210 ((~>) b0123456789876543210 (Foo a0123456789876543210 b0123456789876543210))-      where-        FooSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 t0123456789876543210-    type instance Apply FooSym0 t0123456789876543210 = FooSym1 t0123456789876543210-    type family Case_0123456789876543210 x arg_0123456789876543210 t where-      Case_0123456789876543210 x arg_0123456789876543210 (Foo a _) = a-    type family Lambda_0123456789876543210 x t where-      Lambda_0123456789876543210 x arg_0123456789876543210 = Case_0123456789876543210 x arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Case_0123456789876543210 x y arg_0123456789876543210 t where-      Case_0123456789876543210 x y arg_0123456789876543210 '(_, b) = b-    type family Lambda_0123456789876543210 x y t where-      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 x y arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Case_0123456789876543210 a b x arg_0123456789876543210 t where-      Case_0123456789876543210 a b x arg_0123456789876543210 _ = x-    type family Lambda_0123456789876543210 a b x t where-      Lambda_0123456789876543210 a b x arg_0123456789876543210 = Case_0123456789876543210 a b x arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 x0123456789876543210 b0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall a0123456789876543210-                                                              b0123456789876543210-                                                              x0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 b0123456789876543210 a0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 b0123456789876543210 a0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                              b0123456789876543210-                                                              x0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210Sym3 b0123456789876543210 a0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                              b0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 a0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210-    type family Lambda_0123456789876543210 a b t where-      Lambda_0123456789876543210 a b x = Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) x-    type Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                              b0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 b0123456789876543210 a0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                              b0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 a0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210-    type family Lambda_0123456789876543210 x y t where-      Lambda_0123456789876543210 x y x = x-    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Case_0123456789876543210 x y z arg_0123456789876543210 arg_0123456789876543210 t where-      Case_0123456789876543210 x y z arg_0123456789876543210 arg_0123456789876543210 '(_,-                                                                                       _) = x-    type family Lambda_0123456789876543210 x y z t t where-      Lambda_0123456789876543210 x y z arg_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 x y z arg_0123456789876543210 arg_0123456789876543210 (Apply (Apply Tuple2Sym0 arg_0123456789876543210) arg_0123456789876543210)-    type Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 t0123456789876543210 z0123456789876543210 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              z0123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym4 t0123456789876543210 z0123456789876543210 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 z0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 z0123456789876543210 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              z0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210) arg) (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 z0123456789876543210 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym4 z0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 z0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              z0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 z0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) z0123456789876543210 = Lambda_0123456789876543210Sym3 y0123456789876543210 x0123456789876543210 z0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Lambda_0123456789876543210 x t where-      Lambda_0123456789876543210 x y = y-    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Case_0123456789876543210 x y arg_0123456789876543210 t where-      Case_0123456789876543210 x y arg_0123456789876543210 _ = x-    type family Lambda_0123456789876543210 x y t where-      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 x y arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Case_0123456789876543210 x arg_0123456789876543210 a_0123456789876543210 t where-      Case_0123456789876543210 x arg_0123456789876543210 a_0123456789876543210 _ = x-    type family Lambda_0123456789876543210 x a_0123456789876543210 t where-      Lambda_0123456789876543210 x a_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 x arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t where-      Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 x y = x-    type Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall a_01234567898765432100123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall a_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210-    type Foo8Sym1 (a0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210) =-        Foo8 a0123456789876543210-    instance SuppressUnusedWarnings Foo8Sym0 where-      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())-    data Foo8Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) (Foo a0123456789876543210 b0123456789876543210) a0123456789876543210-      where-        Foo8Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>-                                 Foo8Sym0 a0123456789876543210-    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210-    type Foo7Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo7 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo7Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo7Sym1KindInference) ())-    data Foo7Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 b0123456789876543210-      where-        Foo7Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo7Sym1 a0123456789876543210) arg) (Foo7Sym2 a0123456789876543210 arg) =>-                                 Foo7Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo7Sym1 a0123456789876543210) a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo7Sym0 where-      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())-    data Foo7Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)-      where-        Foo7Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>-                                 Foo7Sym0 a0123456789876543210-    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7Sym1 a0123456789876543210-    type Foo6Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo6 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo6Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo6Sym1KindInference) ())-    data Foo6Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 a0123456789876543210-      where-        Foo6Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo6Sym1 a0123456789876543210) arg) (Foo6Sym2 a0123456789876543210 arg) =>-                                 Foo6Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo6Sym1 a0123456789876543210) a0123456789876543210 = Foo6 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo6Sym0 where-      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())-    data Foo6Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        Foo6Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>-                                 Foo6Sym0 a0123456789876543210-    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6Sym1 a0123456789876543210-    type Foo5Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo5 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo5Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo5Sym1KindInference) ())-    data Foo5Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 b0123456789876543210-      where-        Foo5Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo5Sym1 a0123456789876543210) arg) (Foo5Sym2 a0123456789876543210 arg) =>-                                 Foo5Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo5Sym1 a0123456789876543210) a0123456789876543210 = Foo5 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo5Sym0 where-      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())-    data Foo5Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)-      where-        Foo5Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>-                                 Foo5Sym0 a0123456789876543210-    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5Sym1 a0123456789876543210-    type Foo4Sym3 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: c0123456789876543210) =-        Foo4 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo4Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo4Sym2KindInference) ())-    data Foo4Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210.-                                                                                                                   (~>) c0123456789876543210 a0123456789876543210-      where-        Foo4Sym2KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        a0123456789876543210-                                        arg. 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-    instance SuppressUnusedWarnings (Foo4Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo4Sym1KindInference) ())-    data Foo4Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210-                                                                           c0123456789876543210.-                                                                    (~>) b0123456789876543210 ((~>) c0123456789876543210 a0123456789876543210)-      where-        Foo4Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo4Sym1 a0123456789876543210) arg) (Foo4Sym2 a0123456789876543210 arg) =>-                                 Foo4Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo4Sym1 a0123456789876543210) a0123456789876543210 = Foo4Sym2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo4Sym0 where-      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())-    data Foo4Sym0 :: forall a0123456789876543210-                            b0123456789876543210-                            c0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 a0123456789876543210))-      where-        Foo4Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>-                                 Foo4Sym0 a0123456789876543210-    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4Sym1 a0123456789876543210-    type Foo3Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Foo3 a0123456789876543210-    instance SuppressUnusedWarnings Foo3Sym0 where-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())-    data Foo3Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 a0123456789876543210-      where-        Foo3Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>-                                 Foo3Sym0 a0123456789876543210-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210-    type Foo2Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())-    data Foo2Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 a0123456789876543210-      where-        Foo2Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>-                                 Foo2Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo2Sym0 where-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())-    data Foo2Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        Foo2Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>-                                 Foo2Sym0 a0123456789876543210-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210-    type Foo1Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo1 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())-    data Foo1Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 a0123456789876543210-      where-        Foo1Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>-                                 Foo1Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo1Sym0 where-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())-    data Foo1Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        Foo1Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>-                                 Foo1Sym0 a0123456789876543210-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210-    type Foo0Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo0 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo0Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo0Sym1KindInference) ())-    data Foo0Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 a0123456789876543210-      where-        Foo0Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo0Sym1 a0123456789876543210) arg) (Foo0Sym2 a0123456789876543210 arg) =>-                                 Foo0Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo0Sym1 a0123456789876543210) a0123456789876543210 = Foo0 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo0Sym0 where-      suppressUnusedWarnings = snd (((,) Foo0Sym0KindInference) ())-    data Foo0Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        Foo0Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo0Sym0 arg) (Foo0Sym1 arg) =>-                                 Foo0Sym0 a0123456789876543210-    type instance Apply Foo0Sym0 a0123456789876543210 = Foo0Sym1 a0123456789876543210-    type family Foo8 (a :: Foo a b) :: a where-      Foo8 x = Apply (Apply Lambda_0123456789876543210Sym0 x) x-    type family Foo7 (a :: a) (a :: b) :: b where-      Foo7 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) (Apply (Apply Tuple2Sym0 x) y)-    type family Foo6 (a :: a) (a :: b) :: a where-      Foo6 a b = Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) a) b-    type family Foo5 (a :: a) (a :: b) :: b where-      Foo5 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y-    type family Foo4 (a :: a) (a :: b) (a :: c) :: a where-      Foo4 x y z = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) z) y) z-    type family Foo3 (a :: a) :: a where-      Foo3 x = Apply (Apply Lambda_0123456789876543210Sym0 x) x-    type family Foo2 (a :: a) (a :: b) :: a where-      Foo2 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y-    type family Foo1 (a :: a) (a :: b) :: a where-      Foo1 x a_0123456789876543210 = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a_0123456789876543210) a_0123456789876543210-    type family Foo0 (a :: a) (a :: b) :: a where-      Foo0 a_0123456789876543210 a_0123456789876543210 = Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210-    sFoo8 ::-      forall a b (t :: Foo a b). Sing t -> Sing (Apply Foo8Sym0 t :: a)-    sFoo7 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: b)-    sFoo6 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t :: a)-    sFoo5 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t :: b)-    sFoo4 ::-      forall a b c (t :: a) (t :: b) (t :: c).-      Sing t-      -> Sing t-         -> Sing t -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a)-    sFoo3 :: forall a (t :: a). Sing t -> Sing (Apply Foo3Sym0 t :: a)-    sFoo2 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)-    sFoo1 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)-    sFoo0 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t :: a)-    sFoo8 (sX :: Sing x)-      = (applySing-           ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))-              (\ sArg_0123456789876543210-                 -> case sArg_0123456789876543210 of {-                      (_ :: Sing arg_0123456789876543210)-                        -> (case sArg_0123456789876543210 of {-                              SFoo (sA :: Sing a) _ -> sA }) ::-                             Sing (Case_0123456789876543210 x arg_0123456789876543210 arg_0123456789876543210) })))-          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)-                        -> (case sArg_0123456789876543210 of {-                              STuple2 _ (sB :: Sing b) -> sB }) ::-                             Sing (Case_0123456789876543210 x y arg_0123456789876543210 arg_0123456789876543210) })))-          ((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 a) b) x))-                                 (\ sArg_0123456789876543210-                                    -> case sArg_0123456789876543210 of {-                                         (_ :: Sing arg_0123456789876543210)-                                           -> (case sArg_0123456789876543210 of { _ -> sX }) ::-                                                Sing (Case_0123456789876543210 a b x arg_0123456789876543210 arg_0123456789876543210) }) })))-              sA))-          sB-    sFoo5 (sX :: Sing x) (sY :: Sing y)-      = (applySing-           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y))-              (\ sX -> case sX of { (_ :: 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)-                            -> (case-                                    (applySing-                                       ((applySing ((singFun2 @Tuple2Sym0) STuple2))-                                          sArg_0123456789876543210))-                                      sArg_0123456789876543210-                                of {-                                  STuple2 _ _ -> sX }) ::-                                 Sing (Case_0123456789876543210 x y z arg_0123456789876543210 arg_0123456789876543210 (Apply (Apply Tuple2Sym0 arg_0123456789876543210) arg_0123456789876543210)) })))-              sY))-          sZ-    sFoo3 (sX :: Sing x)-      = (applySing-           ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))-              (\ sY -> case sY of { (_ :: 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)-                        -> (case sArg_0123456789876543210 of { _ -> sX }) ::-                             Sing (Case_0123456789876543210 x y arg_0123456789876543210 arg_0123456789876543210) })))-          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)-                        -> (case sArg_0123456789876543210 of { _ -> sX }) ::-                             Sing (Case_0123456789876543210 x arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210) })))-          sA_0123456789876543210-    sFoo0-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((applySing-               ((singFun2-                   @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210))-                  (\ sX sY-                     -> case ((,) sX) sY of { (,) (_ :: Sing x) (_ :: Sing y) -> sX })))-              sA_0123456789876543210))-          sA_0123456789876543210-    instance SingI (Foo8Sym0 :: (~>) (Foo a b) a) where-      sing = (singFun1 @Foo8Sym0) sFoo8-    instance SingI (Foo7Sym0 :: (~>) a ((~>) b b)) where-      sing = (singFun2 @Foo7Sym0) sFoo7-    instance SingI d => SingI (Foo7Sym1 (d :: a) :: (~>) b b) where-      sing = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 (sing @d))-    instance SingI (Foo6Sym0 :: (~>) a ((~>) b a)) where-      sing = (singFun2 @Foo6Sym0) sFoo6-    instance SingI d => SingI (Foo6Sym1 (d :: a) :: (~>) b a) where-      sing = (singFun1 @(Foo6Sym1 (d :: a))) (sFoo6 (sing @d))-    instance SingI (Foo5Sym0 :: (~>) a ((~>) b b)) where-      sing = (singFun2 @Foo5Sym0) sFoo5-    instance SingI d => SingI (Foo5Sym1 (d :: a) :: (~>) b b) where-      sing = (singFun1 @(Foo5Sym1 (d :: a))) (sFoo5 (sing @d))-    instance SingI (Foo4Sym0 :: (~>) a ((~>) b ((~>) c a))) where-      sing = (singFun3 @Foo4Sym0) sFoo4-    instance SingI d =>-             SingI (Foo4Sym1 (d :: a) :: (~>) b ((~>) c a)) where-      sing = (singFun2 @(Foo4Sym1 (d :: a))) (sFoo4 (sing @d))-    instance (SingI d, SingI d) =>-             SingI (Foo4Sym2 (d :: a) (d :: b) :: (~>) c a) where-      sing-        = (singFun1 @(Foo4Sym2 (d :: a) (d :: b)))-            ((sFoo4 (sing @d)) (sing @d))-    instance SingI (Foo3Sym0 :: (~>) a a) where-      sing = (singFun1 @Foo3Sym0) sFoo3-    instance SingI (Foo2Sym0 :: (~>) a ((~>) b a)) where-      sing = (singFun2 @Foo2Sym0) sFoo2-    instance SingI d => SingI (Foo2Sym1 (d :: a) :: (~>) b a) where-      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))-    instance SingI (Foo1Sym0 :: (~>) a ((~>) b a)) where-      sing = (singFun2 @Foo1Sym0) sFoo1-    instance SingI d => SingI (Foo1Sym1 (d :: a) :: (~>) b a) where-      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))-    instance SingI (Foo0Sym0 :: (~>) a ((~>) b a)) where-      sing = (singFun2 @Foo0Sym0) sFoo0-    instance SingI d => SingI (Foo0Sym1 (d :: a) :: (~>) b a) where-      sing = (singFun1 @(Foo0Sym1 (d :: a))) (sFoo0 (sing @d))-    data instance Sing :: Foo a b -> GHC.Types.Type-      where-        SFoo :: forall a b (n :: a) (n :: b).-                (Sing (n :: a)) -> (Sing (n :: b)) -> Sing (Foo n n)-    type SFoo = (Sing :: Foo a b -> GHC.Types.Type)-    instance (SingKind a, SingKind b) => SingKind (Foo a b) where-      type Demote (Foo a b) = Foo (Demote a) (Demote b)-      fromSing (SFoo b b) = (Foo (fromSing b)) (fromSing b)-      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) }-    instance (SingI n, SingI n) => SingI (Foo (n :: a) (n :: b)) where-      sing = (SFoo sing) sing-    instance SingI (FooSym0 :: (~>) a ((~>) b (Foo a b))) where-      sing = (singFun2 @FooSym0) SFoo-    instance SingI (TyCon2 Foo :: (~>) a ((~>) b (Foo a b))) where-      sing = (singFun2 @(TyCon2 Foo)) SFoo-    instance SingI d =>-             SingI (FooSym1 (d :: a) :: (~>) b (Foo a b)) where-      sing = (singFun1 @(FooSym1 (d :: a))) (SFoo (sing @d))-    instance SingI d =>-             SingI (TyCon1 (Foo (d :: a)) :: (~>) b (Foo a b)) where-      sing = (singFun1 @(TyCon1 (Foo (d :: a)))) (SFoo (sing @d))
+ tests/compile-and-dump/Singletons/Lambdas.ghc88.template view
@@ -0,0 +1,832 @@+Singletons/Lambdas.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo0 :: a -> b -> a+          foo0 = (\ x y -> x)+          foo1 :: a -> b -> a+          foo1 x = (\ _ -> x)+          foo2 :: a -> b -> a+          foo2 x y = (\ _ -> x) y+          foo3 :: a -> a+          foo3 x = (\ y -> y) x+          foo4 :: a -> b -> c -> a+          foo4 x y z = (\ _ _ -> x) y z+          foo5 :: a -> b -> b+          foo5 x y = (\ x -> x) y+          foo6 :: a -> b -> a+          foo6 a b = (\ x -> \ _ -> x) a b+          foo7 :: a -> b -> b+          foo7 x y = (\ (_, b) -> b) (x, y)+          foo8 :: Foo a b -> a+          foo8 x = (\ (Foo a _) -> a) x+          +          data Foo a b = Foo a b |]+  ======>+    foo0 :: a -> b -> a+    foo0 = \ x y -> x+    foo1 :: a -> b -> a+    foo1 x = \ _ -> x+    foo2 :: a -> b -> a+    foo2 x y = (\ _ -> x) y+    foo3 :: a -> a+    foo3 x = (\ y -> y) x+    foo4 :: a -> b -> c -> a+    foo4 x y z = ((\ _ _ -> x) y) z+    foo5 :: a -> b -> b+    foo5 x y = (\ x -> x) y+    foo6 :: a -> b -> a+    foo6 a b = ((\ x -> \ _ -> x) a) b+    foo7 :: a -> b -> b+    foo7 x y = (\ (_, b) -> b) (x, y)+    data Foo a b = Foo a b+    foo8 :: Foo a b -> a+    foo8 x = (\ (Foo a _) -> a) x+    type FooSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =+        Foo t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (FooSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FooSym1KindInference) ())+    data FooSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                   (~>) b0123456789876543210 (Foo a0123456789876543210 b0123456789876543210)+      where+        FooSym1KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (FooSym1 t0123456789876543210) arg) (FooSym2 t0123456789876543210 arg) =>+                                FooSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (FooSym1 t0123456789876543210) t0123456789876543210 = Foo t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: forall a0123456789876543210 b0123456789876543210.+                    (~>) a0123456789876543210 ((~>) b0123456789876543210 (Foo a0123456789876543210 b0123456789876543210))+      where+        FooSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 t0123456789876543210+    type instance Apply FooSym0 t0123456789876543210 = FooSym1 t0123456789876543210+    type family Case_0123456789876543210 arg_0123456789876543210 x t where+      Case_0123456789876543210 arg_0123456789876543210 x (Foo a _) = a+    type family Lambda_0123456789876543210 x t where+      Lambda_0123456789876543210 x arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210+    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Case_0123456789876543210 arg_0123456789876543210 x y t where+      Case_0123456789876543210 arg_0123456789876543210 x y '(_, b) = b+    type family Lambda_0123456789876543210 x y t where+      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210+    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Case_0123456789876543210 arg_0123456789876543210 x a b t where+      Case_0123456789876543210 arg_0123456789876543210 x a b _ = x+    type family Lambda_0123456789876543210 x a b t where+      Lambda_0123456789876543210 x a b arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x a b arg_0123456789876543210+    type Lambda_0123456789876543210Sym4 x0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 b0123456789876543210 a0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall x0123456789876543210+                                                              a0123456789876543210+                                                              b0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym4 x0123456789876543210 a0123456789876543210 b0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym3 b0123456789876543210 a0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 b0123456789876543210 a0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210 b0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210+                                                              a0123456789876543210+                                                              b0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 a0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 a0123456789876543210 b0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 x0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210Sym3 a0123456789876543210 x0123456789876543210 b0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 a0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              a0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Lambda_0123456789876543210 a b t where+      Lambda_0123456789876543210 a b x = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a) b+    type Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                              b0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 b0123456789876543210 a0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                              b0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 a0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210+    type family Lambda_0123456789876543210 x y t where+      Lambda_0123456789876543210 x y x = x+    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 x y z t where+      Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 x y z '(_,+                                                                                       _) = x+    type family Lambda_0123456789876543210 x y z t t 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)+    type Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 t0123456789876543210 z0123456789876543210 y0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              z0123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym4 t0123456789876543210 z0123456789876543210 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 z0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 z0123456789876543210 y0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              z0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210) arg) (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 z0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 z0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym3 z0123456789876543210 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym4 z0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 z0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              z0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 z0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) z0123456789876543210 = Lambda_0123456789876543210Sym3 y0123456789876543210 x0123456789876543210 z0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Lambda_0123456789876543210 x t where+      Lambda_0123456789876543210 x y = y+    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Case_0123456789876543210 arg_0123456789876543210 x y t where+      Case_0123456789876543210 arg_0123456789876543210 x y _ = x+    type family Lambda_0123456789876543210 x y t where+      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210+    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 t where+      Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 _ = x+    type family Lambda_0123456789876543210 x a_0123456789876543210 t where+      Lambda_0123456789876543210 x a_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x a_0123456789876543210 arg_0123456789876543210+    type Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 t t where+      Lambda_0123456789876543210 a_0123456789876543210 a_0123456789876543210 x y = x+    type Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym3 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall a_01234567898765432100123456789876543210+                                                              a_01234567898765432100123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall a_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210+    type Foo8Sym1 (a0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210) =+        Foo8 a0123456789876543210+    instance SuppressUnusedWarnings Foo8Sym0 where+      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())+    data Foo8Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) (Foo a0123456789876543210 b0123456789876543210) a0123456789876543210+      where+        Foo8Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>+                                 Foo8Sym0 a0123456789876543210+    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210+    type Foo7Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo7 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo7Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo7Sym1KindInference) ())+    data Foo7Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 b0123456789876543210+      where+        Foo7Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo7Sym1 a0123456789876543210) arg) (Foo7Sym2 a0123456789876543210 arg) =>+                                 Foo7Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo7Sym1 a0123456789876543210) a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo7Sym0 where+      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())+    data Foo7Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)+      where+        Foo7Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>+                                 Foo7Sym0 a0123456789876543210+    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7Sym1 a0123456789876543210+    type Foo6Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo6 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo6Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo6Sym1KindInference) ())+    data Foo6Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 a0123456789876543210+      where+        Foo6Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo6Sym1 a0123456789876543210) arg) (Foo6Sym2 a0123456789876543210 arg) =>+                                 Foo6Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo6Sym1 a0123456789876543210) a0123456789876543210 = Foo6 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo6Sym0 where+      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())+    data Foo6Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        Foo6Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>+                                 Foo6Sym0 a0123456789876543210+    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6Sym1 a0123456789876543210+    type Foo5Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo5 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo5Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo5Sym1KindInference) ())+    data Foo5Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 b0123456789876543210+      where+        Foo5Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo5Sym1 a0123456789876543210) arg) (Foo5Sym2 a0123456789876543210 arg) =>+                                 Foo5Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo5Sym1 a0123456789876543210) a0123456789876543210 = Foo5 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo5Sym0 where+      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())+    data Foo5Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)+      where+        Foo5Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>+                                 Foo5Sym0 a0123456789876543210+    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5Sym1 a0123456789876543210+    type Foo4Sym3 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: c0123456789876543210) =+        Foo4 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo4Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo4Sym2KindInference) ())+    data Foo4Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210.+                                                                                                                   (~>) c0123456789876543210 a0123456789876543210+      where+        Foo4Sym2KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        a0123456789876543210+                                        arg. 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+    instance SuppressUnusedWarnings (Foo4Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo4Sym1KindInference) ())+    data Foo4Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210+                                                                           c0123456789876543210.+                                                                    (~>) b0123456789876543210 ((~>) c0123456789876543210 a0123456789876543210)+      where+        Foo4Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo4Sym1 a0123456789876543210) arg) (Foo4Sym2 a0123456789876543210 arg) =>+                                 Foo4Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo4Sym1 a0123456789876543210) a0123456789876543210 = Foo4Sym2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo4Sym0 where+      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())+    data Foo4Sym0 :: forall a0123456789876543210+                            b0123456789876543210+                            c0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 a0123456789876543210))+      where+        Foo4Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>+                                 Foo4Sym0 a0123456789876543210+    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4Sym1 a0123456789876543210+    type Foo3Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Foo3 a0123456789876543210+    instance SuppressUnusedWarnings Foo3Sym0 where+      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())+    data Foo3Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 a0123456789876543210+      where+        Foo3Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>+                                 Foo3Sym0 a0123456789876543210+    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210+    type Foo2Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo2Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo2Sym1KindInference) ())+    data Foo2Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 a0123456789876543210+      where+        Foo2Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo2Sym1 a0123456789876543210) arg) (Foo2Sym2 a0123456789876543210 arg) =>+                                 Foo2Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo2Sym1 a0123456789876543210) a0123456789876543210 = Foo2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo2Sym0 where+      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())+    data Foo2Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        Foo2Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>+                                 Foo2Sym0 a0123456789876543210+    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2Sym1 a0123456789876543210+    type Foo1Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo1 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo1Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo1Sym1KindInference) ())+    data Foo1Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 a0123456789876543210+      where+        Foo1Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo1Sym1 a0123456789876543210) arg) (Foo1Sym2 a0123456789876543210 arg) =>+                                 Foo1Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo1Sym1 a0123456789876543210) a0123456789876543210 = Foo1 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo1Sym0 where+      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())+    data Foo1Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        Foo1Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>+                                 Foo1Sym0 a0123456789876543210+    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1Sym1 a0123456789876543210+    type Foo0Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo0 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo0Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo0Sym1KindInference) ())+    data Foo0Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 a0123456789876543210+      where+        Foo0Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo0Sym1 a0123456789876543210) arg) (Foo0Sym2 a0123456789876543210 arg) =>+                                 Foo0Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo0Sym1 a0123456789876543210) a0123456789876543210 = Foo0 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo0Sym0 where+      suppressUnusedWarnings = snd (((,) Foo0Sym0KindInference) ())+    data Foo0Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        Foo0Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo0Sym0 arg) (Foo0Sym1 arg) =>+                                 Foo0Sym0 a0123456789876543210+    type instance Apply Foo0Sym0 a0123456789876543210 = Foo0Sym1 a0123456789876543210+    type family Foo8 (a :: Foo a b) :: a where+      Foo8 x = Apply (Apply Lambda_0123456789876543210Sym0 x) x+    type family Foo7 (a :: a) (a :: b) :: b where+      Foo7 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) (Apply (Apply Tuple2Sym0 x) y)+    type family Foo6 (a :: a) (a :: b) :: a where+      Foo6 a b = Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) a) b+    type family Foo5 (a :: a) (a :: b) :: b where+      Foo5 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y+    type family Foo4 (a :: a) (a :: b) (a :: c) :: a where+      Foo4 x y z = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) z) y) z+    type family Foo3 (a :: a) :: a where+      Foo3 x = Apply (Apply Lambda_0123456789876543210Sym0 x) x+    type family Foo2 (a :: a) (a :: b) :: a where+      Foo2 x y = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y+    type family Foo1 (a :: a) (a :: b) :: a where+      Foo1 x a_0123456789876543210 = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a_0123456789876543210) a_0123456789876543210+    type family Foo0 (a :: a) (a :: b) :: a where+      Foo0 a_0123456789876543210 a_0123456789876543210 = Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210+    sFoo8 ::+      forall a b (t :: Foo a b). Sing t -> Sing (Apply Foo8Sym0 t :: a)+    sFoo7 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: b)+    sFoo6 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo6Sym0 t) t :: a)+    sFoo5 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo5Sym0 t) t :: b)+    sFoo4 ::+      forall a b c (t :: a) (t :: b) (t :: c).+      Sing t+      -> Sing t+         -> Sing t -> Sing (Apply (Apply (Apply Foo4Sym0 t) t) t :: a)+    sFoo3 :: forall a (t :: a). Sing t -> Sing (Apply Foo3Sym0 t :: a)+    sFoo2 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo2Sym0 t) t :: a)+    sFoo1 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo1Sym0 t) t :: a)+    sFoo0 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo0Sym0 t) t :: a)+    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 }) })))+          sX+    sFoo7 (sX :: Sing x) (sY :: Sing y)+      = (applySing+           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y))+              (\ sArg_0123456789876543210+                 -> case sArg_0123456789876543210 of {+                      (_ :: Sing arg_0123456789876543210)+                        -> (id+                              @(Sing (Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210)))+                             (case sArg_0123456789876543210 of {+                                STuple2 _ (sB :: Sing b) -> sB }) })))+          ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX)) sY)+    sFoo6 (sA :: Sing a) (sB :: Sing b)+      = (applySing+           ((applySing+               ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 a) b))+                  (\ sX+                     -> case sX of {+                          (_ :: Sing x)+                            -> (singFun1+                                  @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a) b))+                                 (\ sArg_0123456789876543210+                                    -> case sArg_0123456789876543210 of {+                                         (_ :: Sing arg_0123456789876543210)+                                           -> (id+                                                 @(Sing (Case_0123456789876543210 arg_0123456789876543210 x a b arg_0123456789876543210)))+                                                (case sArg_0123456789876543210 of {+                                                   _ -> sX }) }) })))+              sA))+          sB+    sFoo5 (sX :: Sing x) (sY :: Sing y)+      = (applySing+           ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 x) y))+              (\ sX -> case sX of { (_ :: Sing x) -> sX })))+          sY+    sFoo4 (sX :: Sing x) (sY :: Sing y) (sZ :: Sing z)+      = (applySing+           ((applySing+               ((singFun2+                   @(Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) z))+                  (\ sArg_0123456789876543210 sArg_0123456789876543210+                     -> case+                            ((,) sArg_0123456789876543210) sArg_0123456789876543210+                        of {+                          (,) (_ :: Sing arg_0123456789876543210)+                              (_ :: Sing arg_0123456789876543210)+                            -> (id+                                  @(Sing (Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210 x y z (Apply (Apply Tuple2Sym0 arg_0123456789876543210) arg_0123456789876543210))))+                                 (case+                                      (applySing+                                         ((applySing ((singFun2 @Tuple2Sym0) STuple2))+                                            sArg_0123456789876543210))+                                        sArg_0123456789876543210+                                  of {+                                    STuple2 _ _ -> sX }) })))+              sY))+          sZ+    sFoo3 (sX :: Sing x)+      = (applySing+           ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))+              (\ sY -> case sY of { (_ :: 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 }) })))+          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 }) })))+          sA_0123456789876543210+    sFoo0+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing+           ((applySing+               ((singFun2+                   @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210))+                  (\ sX sY+                     -> case ((,) sX) sY of { (,) (_ :: Sing x) (_ :: Sing y) -> sX })))+              sA_0123456789876543210))+          sA_0123456789876543210+    instance SingI (Foo8Sym0 :: (~>) (Foo a b) a) where+      sing = (singFun1 @Foo8Sym0) sFoo8+    instance SingI (Foo7Sym0 :: (~>) a ((~>) b b)) where+      sing = (singFun2 @Foo7Sym0) sFoo7+    instance SingI d => SingI (Foo7Sym1 (d :: a) :: (~>) b b) where+      sing = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 (sing @d))+    instance SingI (Foo6Sym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @Foo6Sym0) sFoo6+    instance SingI d => SingI (Foo6Sym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(Foo6Sym1 (d :: a))) (sFoo6 (sing @d))+    instance SingI (Foo5Sym0 :: (~>) a ((~>) b b)) where+      sing = (singFun2 @Foo5Sym0) sFoo5+    instance SingI d => SingI (Foo5Sym1 (d :: a) :: (~>) b b) where+      sing = (singFun1 @(Foo5Sym1 (d :: a))) (sFoo5 (sing @d))+    instance SingI (Foo4Sym0 :: (~>) a ((~>) b ((~>) c a))) where+      sing = (singFun3 @Foo4Sym0) sFoo4+    instance SingI d =>+             SingI (Foo4Sym1 (d :: a) :: (~>) b ((~>) c a)) where+      sing = (singFun2 @(Foo4Sym1 (d :: a))) (sFoo4 (sing @d))+    instance (SingI d, SingI d) =>+             SingI (Foo4Sym2 (d :: a) (d :: b) :: (~>) c a) where+      sing+        = (singFun1 @(Foo4Sym2 (d :: a) (d :: b)))+            ((sFoo4 (sing @d)) (sing @d))+    instance SingI (Foo3Sym0 :: (~>) a a) where+      sing = (singFun1 @Foo3Sym0) sFoo3+    instance SingI (Foo2Sym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @Foo2Sym0) sFoo2+    instance SingI d => SingI (Foo2Sym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(Foo2Sym1 (d :: a))) (sFoo2 (sing @d))+    instance SingI (Foo1Sym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @Foo1Sym0) sFoo1+    instance SingI d => SingI (Foo1Sym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(Foo1Sym1 (d :: a))) (sFoo1 (sing @d))+    instance SingI (Foo0Sym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @Foo0Sym0) sFoo0+    instance SingI d => SingI (Foo0Sym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(Foo0Sym1 (d :: a))) (sFoo0 (sing @d))+    data SFoo :: forall a b. Foo a b -> GHC.Types.Type+      where+        SFoo :: forall a b (n :: a) (n :: b).+                (Sing (n :: a)) -> (Sing (n :: b)) -> SFoo (Foo n n)+    type instance Sing @(Foo a b) = SFoo+    instance (SingKind a, SingKind b) => SingKind (Foo a b) where+      type Demote (Foo a b) = Foo (Demote a) (Demote b)+      fromSing (SFoo b b) = (Foo (fromSing b)) (fromSing b)+      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) }+    instance (SingI n, SingI n) => SingI (Foo (n :: a) (n :: b)) where+      sing = (SFoo sing) sing+    instance SingI (FooSym0 :: (~>) a ((~>) b (Foo a b))) where+      sing = (singFun2 @FooSym0) SFoo+    instance SingI d =>+             SingI (FooSym1 (d :: a) :: (~>) b (Foo a b)) where+      sing = (singFun1 @(FooSym1 (d :: a))) (SFoo (sing @d))
− tests/compile-and-dump/Singletons/LambdasComprehensive.ghc86.template 
@@ -1,71 +0,0 @@-Singletons/LambdasComprehensive.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo :: [Nat]-          foo-            = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)]-          bar :: [Nat]-          bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)] |]-  ======>-    foo :: [Nat]-    foo-      = (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 t where-      Lambda_0123456789876543210 x = Apply (Apply (Apply Either_Sym0 PredSym0) SuccSym0) x-    type Lambda_0123456789876543210Sym1 t0123456789876543210 =-        Lambda_0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 t0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall t0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 t0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210-    type BarSym0 = Bar-    type FooSym0 = Foo-    type family Bar :: [Nat] where-      Bar = Apply (Apply MapSym0 (Apply (Apply Either_Sym0 PredSym0) SuccSym0)) (Apply (Apply (:@#@$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[]))-    type family Foo :: [Nat] where-      Foo = Apply (Apply MapSym0 Lambda_0123456789876543210Sym0) (Apply (Apply (:@#@$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[]))-    sBar :: Sing (BarSym0 :: [Nat])-    sFoo :: Sing (FooSym0 :: [Nat])-    sBar-      = (applySing-           ((applySing ((singFun2 @MapSym0) sMap))-              ((applySing-                  ((applySing ((singFun3 @Either_Sym0) sEither_))-                     ((singFun1 @PredSym0) sPred)))-                 ((singFun1 @SuccSym0) SSucc))))-          ((applySing-              ((applySing ((singFun2 @(:@#@$)) SCons))-                 ((applySing ((singFun1 @LeftSym0) SLeft)) SZero)))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((singFun1 @RightSym0) SRight))-                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))-                SNil))-    sFoo-      = (applySing-           ((applySing ((singFun2 @MapSym0) sMap))-              ((singFun1 @Lambda_0123456789876543210Sym0)-                 (\ sX-                    -> case sX of {-                         (_ :: Sing x)-                           -> (applySing-                                 ((applySing-                                     ((applySing ((singFun3 @Either_Sym0) sEither_))-                                        ((singFun1 @PredSym0) sPred)))-                                    ((singFun1 @SuccSym0) SSucc)))-                                sX }))))-          ((applySing-              ((applySing ((singFun2 @(:@#@$)) SCons))-                 ((applySing ((singFun1 @LeftSym0) SLeft)) SZero)))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((singFun1 @RightSym0) SRight))-                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))-                SNil))
+ tests/compile-and-dump/Singletons/LambdasComprehensive.ghc88.template view
@@ -0,0 +1,71 @@+Singletons/LambdasComprehensive.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo :: [Nat]+          foo+            = map (\ x -> either_ pred Succ x) [Left Zero, Right (Succ Zero)]+          bar :: [Nat]+          bar = map (either_ pred Succ) [Left Zero, Right (Succ Zero)] |]+  ======>+    foo :: [Nat]+    foo+      = (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 t where+      Lambda_0123456789876543210 x = Apply (Apply (Apply Either_Sym0 PredSym0) SuccSym0) x+    type Lambda_0123456789876543210Sym1 t0123456789876543210 =+        Lambda_0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 t0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall t0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 t0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210+    type BarSym0 = Bar+    type FooSym0 = Foo+    type family Bar :: [Nat] where+      Bar = Apply (Apply MapSym0 (Apply (Apply Either_Sym0 PredSym0) SuccSym0)) (Apply (Apply (:@#@$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[]))+    type family Foo :: [Nat] where+      Foo = Apply (Apply MapSym0 Lambda_0123456789876543210Sym0) (Apply (Apply (:@#@$) (Apply LeftSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply RightSym0 (Apply SuccSym0 ZeroSym0))) '[]))+    sBar :: Sing (BarSym0 :: [Nat])+    sFoo :: Sing (FooSym0 :: [Nat])+    sBar+      = (applySing+           ((applySing ((singFun2 @MapSym0) sMap))+              ((applySing+                  ((applySing ((singFun3 @Either_Sym0) sEither_))+                     ((singFun1 @PredSym0) sPred)))+                 ((singFun1 @SuccSym0) SSucc))))+          ((applySing+              ((applySing ((singFun2 @(:@#@$)) SCons))+                 ((applySing ((singFun1 @LeftSym0) SLeft)) SZero)))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((singFun1 @RightSym0) SRight))+                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))+                SNil))+    sFoo+      = (applySing+           ((applySing ((singFun2 @MapSym0) sMap))+              ((singFun1 @Lambda_0123456789876543210Sym0)+                 (\ sX+                    -> case sX of {+                         (_ :: Sing x)+                           -> (applySing+                                 ((applySing+                                     ((applySing ((singFun3 @Either_Sym0) sEither_))+                                        ((singFun1 @PredSym0) sPred)))+                                    ((singFun1 @SuccSym0) SSucc)))+                                sX }))))+          ((applySing+              ((applySing ((singFun2 @(:@#@$)) SCons))+                 ((applySing ((singFun1 @LeftSym0) SLeft)) SZero)))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((singFun1 @RightSym0) SRight))+                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))+                SNil))
− tests/compile-and-dump/Singletons/LetStatements.ghc86.template 
@@ -1,1002 +0,0 @@-Singletons/LetStatements.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo1 :: Nat -> Nat-          foo1 x-            = let-                y :: Nat-                y = Succ Zero-              in y-          foo2 :: Nat-          foo2-            = let-                y = Succ Zero-                z = Succ y-              in z-          foo3 :: Nat -> Nat-          foo3 x-            = let-                y :: Nat-                y = Succ x-              in y-          foo4 :: Nat -> Nat-          foo4 x-            = let-                f :: Nat -> Nat-                f y = Succ y-              in f x-          foo5 :: Nat -> Nat-          foo5 x-            = let-                f :: Nat -> Nat-                f y-                  = let-                      z :: Nat-                      z = Succ y-                    in Succ z-              in f x-          foo6 :: Nat -> Nat-          foo6 x-            = let-                f :: Nat -> Nat-                f y = Succ y in-              let-                z :: Nat-                z = f x-              in z-          foo7 :: Nat -> Nat-          foo7 x-            = let-                x :: Nat-                x = Zero-              in x-          foo8 :: Nat -> Nat-          foo8 x-            = let-                z :: Nat-                z = (\ x -> x) Zero-              in z-          foo9 :: Nat -> Nat-          foo9 x-            = let-                z :: Nat -> Nat-                z = (\ x -> x)-              in z x-          foo10 :: Nat -> Nat-          foo10 x-            = let-                (+) :: Nat -> Nat -> Nat-                Zero + m = m-                (Succ n) + m = Succ (n + m)-              in (Succ Zero) + x-          foo11 :: Nat -> Nat-          foo11 x-            = let-                (+) :: Nat -> Nat -> Nat-                Zero + m = m-                (Succ n) + m = Succ (n + m)-                z :: Nat-                z = x-              in (Succ Zero) + z-          foo12 :: Nat -> Nat-          foo12 x-            = let-                (+) :: Nat -> Nat -> Nat-                Zero + m = m-                (Succ n) + m = Succ (n + x)-              in x + (Succ (Succ Zero))-          foo13 :: forall a. a -> a-          foo13 x-            = let-                bar :: a-                bar = x-              in foo13_ bar-          foo13_ :: a -> a-          foo13_ y = y-          foo14 :: Nat -> (Nat, Nat)-          foo14 x = let (y, z) = (Succ x, x) in (z, y) |]-  ======>-    foo1 :: Nat -> Nat-    foo1 x-      = let-          y :: Nat-          y = Succ Zero-        in y-    foo2 :: Nat-    foo2-      = let-          y = Succ Zero-          z = Succ y-        in z-    foo3 :: Nat -> Nat-    foo3 x-      = let-          y :: Nat-          y = Succ x-        in y-    foo4 :: Nat -> Nat-    foo4 x-      = let-          f :: Nat -> Nat-          f y = Succ y-        in f x-    foo5 :: Nat -> Nat-    foo5 x-      = let-          f :: Nat -> Nat-          f y-            = let-                z :: Nat-                z = Succ y-              in Succ z-        in f x-    foo6 :: Nat -> Nat-    foo6 x-      = let-          f :: Nat -> Nat-          f y = Succ y in-        let-          z :: Nat-          z = f x-        in z-    foo7 :: Nat -> Nat-    foo7 x-      = let-          x :: Nat-          x = Zero-        in x-    foo8 :: Nat -> Nat-    foo8 x-      = let-          z :: Nat-          z = (\ x -> x) Zero-        in z-    foo9 :: Nat -> Nat-    foo9 x-      = let-          z :: Nat -> Nat-          z = \ x -> x-        in z x-    foo10 :: Nat -> Nat-    foo10 x-      = let-          (+) :: Nat -> Nat -> Nat-          (+) Zero m = m-          (+) (Succ n) m = Succ (n + m)-        in (Succ Zero + x)-    foo11 :: Nat -> Nat-    foo11 x-      = let-          (+) :: Nat -> Nat -> Nat-          z :: Nat-          (+) Zero m = m-          (+) (Succ n) m = Succ (n + m)-          z = x-        in (Succ Zero + z)-    foo12 :: Nat -> Nat-    foo12 x-      = let-          (+) :: Nat -> Nat -> Nat-          (+) Zero m = m-          (+) (Succ n) m = Succ (n + x)-        in (x + Succ (Succ Zero))-    foo13 :: forall a. a -> a-    foo13 x-      = let-          bar :: a-          bar = x-        in foo13_ bar-    foo13_ :: a -> a-    foo13_ y = y-    foo14 :: Nat -> (Nat, Nat)-    foo14 x = let (y, z) = (Succ x, x) in (z, y)-    type family Case_0123456789876543210 x t where-      Case_0123456789876543210 x '(y_0123456789876543210,-                                   _) = y_0123456789876543210-    type family Case_0123456789876543210 x t where-      Case_0123456789876543210 x '(_,-                                   y_0123456789876543210) = y_0123456789876543210-    type Let0123456789876543210YSym1 x0123456789876543210 =-        Let0123456789876543210Y x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210YSym0KindInference) ())-    data Let0123456789876543210YSym0 x0123456789876543210-      where-        Let0123456789876543210YSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>-                                                    Let0123456789876543210YSym0 x0123456789876543210-    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210-    type Let0123456789876543210ZSym1 x0123456789876543210 =-        Let0123456789876543210Z x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())-    data Let0123456789876543210ZSym0 x0123456789876543210-      where-        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 x0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210-    type Let0123456789876543210X_0123456789876543210Sym1 x0123456789876543210 =-        Let0123456789876543210X_0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210X_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,) Let0123456789876543210X_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210-      where-        Let0123456789876543210X_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                                               arg. SameKind (Apply Let0123456789876543210X_0123456789876543210Sym0 arg) (Let0123456789876543210X_0123456789876543210Sym1 arg) =>-                                                                        Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210X_0123456789876543210 x0123456789876543210-    type family Let0123456789876543210Y x where-      Let0123456789876543210Y x = Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)-    type family Let0123456789876543210Z x where-      Let0123456789876543210Z x = Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)-    type family Let0123456789876543210X_0123456789876543210 x where-      Let0123456789876543210X_0123456789876543210 x = Apply (Apply Tuple2Sym0 (Apply SuccSym0 x)) x-    type Let0123456789876543210BarSym1 x0123456789876543210 =-        Let0123456789876543210Bar x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210BarSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210BarSym0KindInference) ())-    data Let0123456789876543210BarSym0 x0123456789876543210-      where-        Let0123456789876543210BarSym0KindInference :: forall x0123456789876543210-                                                             arg. SameKind (Apply Let0123456789876543210BarSym0 arg) (Let0123456789876543210BarSym1 arg) =>-                                                      Let0123456789876543210BarSym0 x0123456789876543210-    type instance Apply Let0123456789876543210BarSym0 x0123456789876543210 = Let0123456789876543210Bar x0123456789876543210-    type family Let0123456789876543210Bar x :: a where-      Let0123456789876543210Bar x = x-    type (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: forall x0123456789876543210-                                                      a0123456789876543210-                                                      a0123456789876543210-                                                      arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>-                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) a0123456789876543210 x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: forall x0123456789876543210-                                                     a0123456789876543210-                                                     arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>-                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: forall x0123456789876543210-                                                    arg. SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210-    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (a :: Nat) (a :: Nat) :: Nat where-      (<<<%%%%%%%%%%%%%%%%%%%%) x  'Zero m = m-      (<<<%%%%%%%%%%%%%%%%%%%%) x ( 'Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) n) x)-    type Let0123456789876543210ZSym1 x0123456789876543210 =-        Let0123456789876543210Z x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())-    data Let0123456789876543210ZSym0 x0123456789876543210-      where-        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 x0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210-    type (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: forall x0123456789876543210-                                                      a0123456789876543210-                                                      a0123456789876543210-                                                      arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>-                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) a0123456789876543210 x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: forall x0123456789876543210-                                                     a0123456789876543210-                                                     arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>-                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: forall x0123456789876543210-                                                    arg. SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210-    type family Let0123456789876543210Z x :: Nat where-      Let0123456789876543210Z x = x-    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (a :: Nat) (a :: Nat) :: Nat where-      (<<<%%%%%%%%%%%%%%%%%%%%) x  'Zero m = m-      (<<<%%%%%%%%%%%%%%%%%%%%) x ( 'Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) n) m)-    type (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: forall x0123456789876543210-                                                      a0123456789876543210-                                                      a0123456789876543210-                                                      arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>-                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) a0123456789876543210 x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: forall x0123456789876543210-                                                     a0123456789876543210-                                                     arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>-                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210-    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where-      suppressUnusedWarnings-        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())-    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-      where-        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: forall x0123456789876543210-                                                    arg. SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>-                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210-    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210-    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (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 x a_0123456789876543210 t where-      Lambda_0123456789876543210 x a_0123456789876543210 x = x-    type Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              a_01234567898765432100123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type Let0123456789876543210ZSym2 x0123456789876543210 (a0123456789876543210 :: Nat) =-        Let0123456789876543210Z x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym1KindInference) ())-    data Let0123456789876543210ZSym1 x0123456789876543210 :: (~>) Nat Nat-      where-        Let0123456789876543210ZSym1KindInference :: forall x0123456789876543210-                                                           a0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210ZSym1 x0123456789876543210) arg) (Let0123456789876543210ZSym2 x0123456789876543210 arg) =>-                                                    Let0123456789876543210ZSym1 x0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210ZSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210Z x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())-    data Let0123456789876543210ZSym0 x0123456789876543210-      where-        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 x0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210ZSym1 x0123456789876543210-    type family Let0123456789876543210Z x (a :: Nat) :: Nat where-      Let0123456789876543210Z x a_0123456789876543210 = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) a_0123456789876543210) a_0123456789876543210-    type family Lambda_0123456789876543210 x t where-      Lambda_0123456789876543210 x x = x-    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type Let0123456789876543210ZSym1 x0123456789876543210 =-        Let0123456789876543210Z x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())-    data Let0123456789876543210ZSym0 x0123456789876543210-      where-        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 x0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210-    type family Let0123456789876543210Z x :: Nat where-      Let0123456789876543210Z x = Apply (Apply Lambda_0123456789876543210Sym0 x) ZeroSym0-    type Let0123456789876543210XSym1 x0123456789876543210 =-        Let0123456789876543210X x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210XSym0KindInference) ())-    data Let0123456789876543210XSym0 x0123456789876543210-      where-        Let0123456789876543210XSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>-                                                    Let0123456789876543210XSym0 x0123456789876543210-    type instance Apply Let0123456789876543210XSym0 x0123456789876543210 = Let0123456789876543210X x0123456789876543210-    type family Let0123456789876543210X x :: Nat where-      Let0123456789876543210X x = ZeroSym0-    type Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) =-        Let0123456789876543210F x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210FSym1KindInference) ())-    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat-      where-        Let0123456789876543210FSym1KindInference :: forall x0123456789876543210-                                                           a0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>-                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210FSym0KindInference) ())-    data Let0123456789876543210FSym0 x0123456789876543210-      where-        Let0123456789876543210FSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>-                                                    Let0123456789876543210FSym0 x0123456789876543210-    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210-    type family Let0123456789876543210F x (a :: Nat) :: Nat where-      Let0123456789876543210F x y = Apply SuccSym0 y-    type Let0123456789876543210ZSym1 x0123456789876543210 =-        Let0123456789876543210Z x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())-    data Let0123456789876543210ZSym0 x0123456789876543210-      where-        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 x0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210-    type family Let0123456789876543210Z x :: Nat where-      Let0123456789876543210Z x = Apply (Let0123456789876543210FSym1 x) x-    type Let0123456789876543210ZSym2 x0123456789876543210 y0123456789876543210 =-        Let0123456789876543210Z x0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym1KindInference) ())-    data Let0123456789876543210ZSym1 x0123456789876543210 y0123456789876543210-      where-        Let0123456789876543210ZSym1KindInference :: forall x0123456789876543210-                                                           y0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210ZSym1 x0123456789876543210) arg) (Let0123456789876543210ZSym2 x0123456789876543210 arg) =>-                                                    Let0123456789876543210ZSym1 x0123456789876543210 y0123456789876543210-    type instance Apply (Let0123456789876543210ZSym1 x0123456789876543210) y0123456789876543210 = Let0123456789876543210Z x0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210ZSym0KindInference) ())-    data Let0123456789876543210ZSym0 x0123456789876543210-      where-        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>-                                                    Let0123456789876543210ZSym0 x0123456789876543210-    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210ZSym1 x0123456789876543210-    type family Let0123456789876543210Z x y :: Nat where-      Let0123456789876543210Z x y = Apply SuccSym0 y-    type Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) =-        Let0123456789876543210F x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210FSym1KindInference) ())-    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat-      where-        Let0123456789876543210FSym1KindInference :: forall x0123456789876543210-                                                           a0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>-                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210FSym0KindInference) ())-    data Let0123456789876543210FSym0 x0123456789876543210-      where-        Let0123456789876543210FSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>-                                                    Let0123456789876543210FSym0 x0123456789876543210-    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210-    type family Let0123456789876543210F x (a :: Nat) :: Nat where-      Let0123456789876543210F x y = Apply SuccSym0 (Let0123456789876543210ZSym2 x y)-    type Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) =-        Let0123456789876543210F x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210FSym1KindInference) ())-    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat-      where-        Let0123456789876543210FSym1KindInference :: forall x0123456789876543210-                                                           a0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>-                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210FSym0KindInference) ())-    data Let0123456789876543210FSym0 x0123456789876543210-      where-        Let0123456789876543210FSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>-                                                    Let0123456789876543210FSym0 x0123456789876543210-    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210-    type family Let0123456789876543210F x (a :: Nat) :: Nat where-      Let0123456789876543210F x y = Apply SuccSym0 y-    type Let0123456789876543210YSym1 x0123456789876543210 =-        Let0123456789876543210Y x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210YSym0KindInference) ())-    data Let0123456789876543210YSym0 x0123456789876543210-      where-        Let0123456789876543210YSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>-                                                    Let0123456789876543210YSym0 x0123456789876543210-    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210-    type family Let0123456789876543210Y x :: Nat where-      Let0123456789876543210Y x = Apply SuccSym0 x-    type Let0123456789876543210YSym0 = Let0123456789876543210Y-    type Let0123456789876543210ZSym0 = Let0123456789876543210Z-    type family Let0123456789876543210Y where-      Let0123456789876543210Y = Apply SuccSym0 ZeroSym0-    type family Let0123456789876543210Z where-      Let0123456789876543210Z = Apply SuccSym0 Let0123456789876543210YSym0-    type Let0123456789876543210YSym1 x0123456789876543210 =-        Let0123456789876543210Y x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210YSym0KindInference) ())-    data Let0123456789876543210YSym0 x0123456789876543210-      where-        Let0123456789876543210YSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>-                                                    Let0123456789876543210YSym0 x0123456789876543210-    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210-    type family Let0123456789876543210Y x :: Nat where-      Let0123456789876543210Y x = Apply SuccSym0 ZeroSym0-    type Foo14Sym1 (a0123456789876543210 :: Nat) =-        Foo14 a0123456789876543210-    instance SuppressUnusedWarnings Foo14Sym0 where-      suppressUnusedWarnings = snd (((,) Foo14Sym0KindInference) ())-    data Foo14Sym0 :: (~>) Nat (Nat, Nat)-      where-        Foo14Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply Foo14Sym0 arg) (Foo14Sym1 arg) =>-                                  Foo14Sym0 a0123456789876543210-    type instance Apply Foo14Sym0 a0123456789876543210 = Foo14 a0123456789876543210-    type Foo13_Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Foo13_ a0123456789876543210-    instance SuppressUnusedWarnings Foo13_Sym0 where-      suppressUnusedWarnings = snd (((,) Foo13_Sym0KindInference) ())-    data Foo13_Sym0 :: forall a0123456789876543210.-                       (~>) a0123456789876543210 a0123456789876543210-      where-        Foo13_Sym0KindInference :: forall a0123456789876543210-                                          arg. SameKind (Apply Foo13_Sym0 arg) (Foo13_Sym1 arg) =>-                                   Foo13_Sym0 a0123456789876543210-    type instance Apply Foo13_Sym0 a0123456789876543210 = Foo13_ a0123456789876543210-    type Foo13Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Foo13 a0123456789876543210-    instance SuppressUnusedWarnings Foo13Sym0 where-      suppressUnusedWarnings = snd (((,) Foo13Sym0KindInference) ())-    data Foo13Sym0 :: forall a0123456789876543210.-                      (~>) a0123456789876543210 a0123456789876543210-      where-        Foo13Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply Foo13Sym0 arg) (Foo13Sym1 arg) =>-                                  Foo13Sym0 a0123456789876543210-    type instance Apply Foo13Sym0 a0123456789876543210 = Foo13 a0123456789876543210-    type Foo12Sym1 (a0123456789876543210 :: Nat) =-        Foo12 a0123456789876543210-    instance SuppressUnusedWarnings Foo12Sym0 where-      suppressUnusedWarnings = snd (((,) Foo12Sym0KindInference) ())-    data Foo12Sym0 :: (~>) Nat Nat-      where-        Foo12Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply Foo12Sym0 arg) (Foo12Sym1 arg) =>-                                  Foo12Sym0 a0123456789876543210-    type instance Apply Foo12Sym0 a0123456789876543210 = Foo12 a0123456789876543210-    type Foo11Sym1 (a0123456789876543210 :: Nat) =-        Foo11 a0123456789876543210-    instance SuppressUnusedWarnings Foo11Sym0 where-      suppressUnusedWarnings = snd (((,) Foo11Sym0KindInference) ())-    data Foo11Sym0 :: (~>) Nat Nat-      where-        Foo11Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply Foo11Sym0 arg) (Foo11Sym1 arg) =>-                                  Foo11Sym0 a0123456789876543210-    type instance Apply Foo11Sym0 a0123456789876543210 = Foo11 a0123456789876543210-    type Foo10Sym1 (a0123456789876543210 :: Nat) =-        Foo10 a0123456789876543210-    instance SuppressUnusedWarnings Foo10Sym0 where-      suppressUnusedWarnings = snd (((,) Foo10Sym0KindInference) ())-    data Foo10Sym0 :: (~>) Nat Nat-      where-        Foo10Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply Foo10Sym0 arg) (Foo10Sym1 arg) =>-                                  Foo10Sym0 a0123456789876543210-    type instance Apply Foo10Sym0 a0123456789876543210 = Foo10 a0123456789876543210-    type Foo9Sym1 (a0123456789876543210 :: Nat) =-        Foo9 a0123456789876543210-    instance SuppressUnusedWarnings Foo9Sym0 where-      suppressUnusedWarnings = snd (((,) Foo9Sym0KindInference) ())-    data Foo9Sym0 :: (~>) Nat Nat-      where-        Foo9Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo9Sym0 arg) (Foo9Sym1 arg) =>-                                 Foo9Sym0 a0123456789876543210-    type instance Apply Foo9Sym0 a0123456789876543210 = Foo9 a0123456789876543210-    type Foo8Sym1 (a0123456789876543210 :: Nat) =-        Foo8 a0123456789876543210-    instance SuppressUnusedWarnings Foo8Sym0 where-      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())-    data Foo8Sym0 :: (~>) Nat Nat-      where-        Foo8Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>-                                 Foo8Sym0 a0123456789876543210-    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210-    type Foo7Sym1 (a0123456789876543210 :: Nat) =-        Foo7 a0123456789876543210-    instance SuppressUnusedWarnings Foo7Sym0 where-      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())-    data Foo7Sym0 :: (~>) Nat Nat-      where-        Foo7Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>-                                 Foo7Sym0 a0123456789876543210-    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7 a0123456789876543210-    type Foo6Sym1 (a0123456789876543210 :: Nat) =-        Foo6 a0123456789876543210-    instance SuppressUnusedWarnings Foo6Sym0 where-      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())-    data Foo6Sym0 :: (~>) Nat Nat-      where-        Foo6Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>-                                 Foo6Sym0 a0123456789876543210-    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6 a0123456789876543210-    type Foo5Sym1 (a0123456789876543210 :: Nat) =-        Foo5 a0123456789876543210-    instance SuppressUnusedWarnings Foo5Sym0 where-      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())-    data Foo5Sym0 :: (~>) Nat Nat-      where-        Foo5Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>-                                 Foo5Sym0 a0123456789876543210-    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210-    type Foo4Sym1 (a0123456789876543210 :: Nat) =-        Foo4 a0123456789876543210-    instance SuppressUnusedWarnings Foo4Sym0 where-      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())-    data Foo4Sym0 :: (~>) Nat Nat-      where-        Foo4Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>-                                 Foo4Sym0 a0123456789876543210-    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210-    type Foo3Sym1 (a0123456789876543210 :: Nat) =-        Foo3 a0123456789876543210-    instance SuppressUnusedWarnings Foo3Sym0 where-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())-    data Foo3Sym0 :: (~>) Nat Nat-      where-        Foo3Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>-                                 Foo3Sym0 a0123456789876543210-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210-    type Foo2Sym0 = Foo2-    type Foo1Sym1 (a0123456789876543210 :: Nat) =-        Foo1 a0123456789876543210-    instance SuppressUnusedWarnings Foo1Sym0 where-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())-    data Foo1Sym0 :: (~>) Nat Nat-      where-        Foo1Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>-                                 Foo1Sym0 a0123456789876543210-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210-    type family Foo14 (a :: Nat) :: (Nat, Nat) where-      Foo14 x = Apply (Apply Tuple2Sym0 (Let0123456789876543210ZSym1 x)) (Let0123456789876543210YSym1 x)-    type family Foo13_ (a :: a) :: a where-      Foo13_ y = y-    type family Foo13 (a :: a) :: a where-      Foo13 x = Apply Foo13_Sym0 (Let0123456789876543210BarSym1 x)-    type family Foo12 (a :: Nat) :: Nat where-      Foo12 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))-    type family Foo11 (a :: Nat) :: Nat where-      Foo11 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789876543210ZSym1 x)-    type family Foo10 (a :: Nat) :: Nat where-      Foo10 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (Apply SuccSym0 ZeroSym0)) x-    type family Foo9 (a :: Nat) :: Nat where-      Foo9 x = Apply (Let0123456789876543210ZSym1 x) x-    type family Foo8 (a :: Nat) :: Nat where-      Foo8 x = Let0123456789876543210ZSym1 x-    type family Foo7 (a :: Nat) :: Nat where-      Foo7 x = Let0123456789876543210XSym1 x-    type family Foo6 (a :: Nat) :: Nat where-      Foo6 x = Let0123456789876543210ZSym1 x-    type family Foo5 (a :: Nat) :: Nat where-      Foo5 x = Apply (Let0123456789876543210FSym1 x) x-    type family Foo4 (a :: Nat) :: Nat where-      Foo4 x = Apply (Let0123456789876543210FSym1 x) x-    type family Foo3 (a :: Nat) :: Nat where-      Foo3 x = Let0123456789876543210YSym1 x-    type family Foo2 :: Nat where-      Foo2 = Let0123456789876543210ZSym0-    type family Foo1 (a :: Nat) :: Nat where-      Foo1 x = Let0123456789876543210YSym1 x-    sFoo14 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo14Sym0 t :: (Nat, Nat))-    sFoo13_ ::-      forall a (t :: a). Sing t -> Sing (Apply Foo13_Sym0 t :: a)-    sFoo13 ::-      forall a (t :: a). Sing t -> Sing (Apply Foo13Sym0 t :: a)-    sFoo12 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo12Sym0 t :: Nat)-    sFoo11 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo11Sym0 t :: Nat)-    sFoo10 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo10Sym0 t :: Nat)-    sFoo9 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo9Sym0 t :: Nat)-    sFoo8 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo8Sym0 t :: Nat)-    sFoo7 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo7Sym0 t :: Nat)-    sFoo6 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo6Sym0 t :: Nat)-    sFoo5 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo5Sym0 t :: Nat)-    sFoo4 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo4Sym0 t :: Nat)-    sFoo3 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo3Sym0 t :: Nat)-    sFoo2 :: Sing (Foo2Sym0 :: Nat)-    sFoo1 ::-      forall (t :: Nat). Sing t -> Sing (Apply Foo1Sym0 t :: Nat)-    sFoo14 (sX :: Sing x)-      = let-          sY :: Sing (Let0123456789876543210YSym1 x)-          sZ :: Sing (Let0123456789876543210ZSym1 x)-          sX_0123456789876543210 ::-            Sing (Let0123456789876543210X_0123456789876543210Sym1 x)-          sY-            = (case sX_0123456789876543210 of {-                 STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _-                   -> sY_0123456789876543210 }) ::-                Sing (Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x))-          sZ-            = (case sX_0123456789876543210 of {-                 STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210)-                   -> sY_0123456789876543210 }) ::-                Sing (Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x))-          sX_0123456789876543210-            = (applySing-                 ((applySing ((singFun2 @Tuple2Sym0) STuple2))-                    ((applySing ((singFun1 @SuccSym0) SSucc)) sX)))-                sX-        in (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sZ)) sY-    sFoo13_ (sY :: Sing y) = sY-    sFoo13 (sX :: Sing x)-      = let-          sBar :: Sing (Let0123456789876543210BarSym1 x :: a)-          sBar = sX-        in (applySing ((singFun1 @Foo13_Sym0) sFoo13_)) sBar-    sFoo12 (sX :: Sing x)-      = let-          (%+) ::-            forall (t :: Nat) (t :: Nat).-            Sing t-            -> Sing t-               -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)-          (%+) SZero (sM :: Sing m) = sM-          (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)-            = (applySing ((singFun1 @SuccSym0) SSucc))-                ((applySing-                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))-                       sN))-                   sX)-        in-          (applySing-             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))-                sX))-            ((applySing ((singFun1 @SuccSym0) SSucc))-               ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))-    sFoo11 (sX :: Sing x)-      = let-          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)-          (%+) ::-            forall (t :: Nat) (t :: Nat).-            Sing t-            -> Sing t-               -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)-          sZ = sX-          (%+) SZero (sM :: Sing m) = sM-          (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)-            = (applySing ((singFun1 @SuccSym0) SSucc))-                ((applySing-                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))-                       sN))-                   sM)-        in-          (applySing-             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))-                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-            sZ-    sFoo10 (sX :: Sing x)-      = let-          (%+) ::-            forall (t :: Nat) (t :: Nat).-            Sing t-            -> Sing t-               -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)-          (%+) SZero (sM :: Sing m) = sM-          (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)-            = (applySing ((singFun1 @SuccSym0) SSucc))-                ((applySing-                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))-                       sN))-                   sM)-        in-          (applySing-             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))-                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-            sX-    sFoo9 (sX :: Sing x)-      = let-          sZ ::-            forall (t :: Nat).-            Sing t -> Sing (Apply (Let0123456789876543210ZSym1 x) t :: Nat)-          sZ (sA_0123456789876543210 :: Sing a_0123456789876543210)-            = (applySing-                 ((singFun1-                     @(Apply (Apply Lambda_0123456789876543210Sym0 x) a_0123456789876543210))-                    (\ sX -> case sX of { (_ :: Sing x) -> sX })))-                sA_0123456789876543210-        in (applySing ((singFun1 @(Let0123456789876543210ZSym1 x)) sZ)) sX-    sFoo8 (sX :: Sing x)-      = let-          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)-          sZ-            = (applySing-                 ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))-                    (\ sX -> case sX of { (_ :: Sing x) -> sX })))-                SZero-        in sZ-    sFoo7 (sX :: Sing x)-      = let-          sX :: Sing (Let0123456789876543210XSym1 x :: Nat)-          sX = SZero-        in sX-    sFoo6 (sX :: Sing x)-      = let-          sF ::-            forall (t :: Nat).-            Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)-          sF (sY :: Sing y) = (applySing ((singFun1 @SuccSym0) SSucc)) sY in-        let-          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)-          sZ-            = (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX-        in sZ-    sFoo5 (sX :: Sing x)-      = let-          sF ::-            forall (t :: Nat).-            Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)-          sF (sY :: Sing y)-            = let-                sZ :: Sing (Let0123456789876543210ZSym2 x y :: Nat)-                sZ = (applySing ((singFun1 @SuccSym0) SSucc)) sY-              in (applySing ((singFun1 @SuccSym0) SSucc)) sZ-        in (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX-    sFoo4 (sX :: Sing x)-      = let-          sF ::-            forall (t :: Nat).-            Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)-          sF (sY :: Sing y) = (applySing ((singFun1 @SuccSym0) SSucc)) sY-        in (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX-    sFoo3 (sX :: Sing x)-      = let-          sY :: Sing (Let0123456789876543210YSym1 x :: Nat)-          sY = (applySing ((singFun1 @SuccSym0) SSucc)) sX-        in sY-    sFoo2-      = let-          sY :: Sing Let0123456789876543210YSym0-          sZ :: Sing Let0123456789876543210ZSym0-          sY = (applySing ((singFun1 @SuccSym0) SSucc)) SZero-          sZ = (applySing ((singFun1 @SuccSym0) SSucc)) sY-        in sZ-    sFoo1 (sX :: Sing x)-      = let-          sY :: Sing (Let0123456789876543210YSym1 x :: Nat)-          sY = (applySing ((singFun1 @SuccSym0) SSucc)) SZero-        in sY-    instance SingI (Foo14Sym0 :: (~>) Nat (Nat, Nat)) where-      sing = (singFun1 @Foo14Sym0) sFoo14-    instance SingI (Foo13_Sym0 :: (~>) a a) where-      sing = (singFun1 @Foo13_Sym0) sFoo13_-    instance SingI (Foo13Sym0 :: (~>) a a) where-      sing = (singFun1 @Foo13Sym0) sFoo13-    instance SingI (Foo12Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo12Sym0) sFoo12-    instance SingI (Foo11Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo11Sym0) sFoo11-    instance SingI (Foo10Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo10Sym0) sFoo10-    instance SingI (Foo9Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo9Sym0) sFoo9-    instance SingI (Foo8Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo8Sym0) sFoo8-    instance SingI (Foo7Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo7Sym0) sFoo7-    instance SingI (Foo6Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo6Sym0) sFoo6-    instance SingI (Foo5Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo5Sym0) sFoo5-    instance SingI (Foo4Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo4Sym0) sFoo4-    instance SingI (Foo3Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo3Sym0) sFoo3-    instance SingI (Foo1Sym0 :: (~>) Nat Nat) where-      sing = (singFun1 @Foo1Sym0) sFoo1
+ tests/compile-and-dump/Singletons/LetStatements.ghc88.template view
@@ -0,0 +1,1004 @@+Singletons/LetStatements.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo1 :: Nat -> Nat+          foo1 x+            = let+                y :: Nat+                y = Succ Zero+              in y+          foo2 :: Nat+          foo2+            = let+                y = Succ Zero+                z = Succ y+              in z+          foo3 :: Nat -> Nat+          foo3 x+            = let+                y :: Nat+                y = Succ x+              in y+          foo4 :: Nat -> Nat+          foo4 x+            = let+                f :: Nat -> Nat+                f y = Succ y+              in f x+          foo5 :: Nat -> Nat+          foo5 x+            = let+                f :: Nat -> Nat+                f y+                  = let+                      z :: Nat+                      z = Succ y+                    in Succ z+              in f x+          foo6 :: Nat -> Nat+          foo6 x+            = let+                f :: Nat -> Nat+                f y = Succ y in+              let+                z :: Nat+                z = f x+              in z+          foo7 :: Nat -> Nat+          foo7 x+            = let+                x :: Nat+                x = Zero+              in x+          foo8 :: Nat -> Nat+          foo8 x+            = let+                z :: Nat+                z = (\ x -> x) Zero+              in z+          foo9 :: Nat -> Nat+          foo9 x+            = let+                z :: Nat -> Nat+                z = (\ x -> x)+              in z x+          foo10 :: Nat -> Nat+          foo10 x+            = let+                (+) :: Nat -> Nat -> Nat+                Zero + m = m+                (Succ n) + m = Succ (n + m)+              in (Succ Zero) + x+          foo11 :: Nat -> Nat+          foo11 x+            = let+                (+) :: Nat -> Nat -> Nat+                Zero + m = m+                (Succ n) + m = Succ (n + m)+                z :: Nat+                z = x+              in (Succ Zero) + z+          foo12 :: Nat -> Nat+          foo12 x+            = let+                (+) :: Nat -> Nat -> Nat+                Zero + m = m+                (Succ n) + m = Succ (n + x)+              in x + (Succ (Succ Zero))+          foo13 :: forall a. a -> a+          foo13 x+            = let+                bar :: a+                bar = x+              in foo13_ bar+          foo13_ :: a -> a+          foo13_ y = y+          foo14 :: Nat -> (Nat, Nat)+          foo14 x = let (y, z) = (Succ x, x) in (z, y) |]+  ======>+    foo1 :: Nat -> Nat+    foo1 x+      = let+          y :: Nat+          y = Succ Zero+        in y+    foo2 :: Nat+    foo2+      = let+          y = Succ Zero+          z = Succ y+        in z+    foo3 :: Nat -> Nat+    foo3 x+      = let+          y :: Nat+          y = Succ x+        in y+    foo4 :: Nat -> Nat+    foo4 x+      = let+          f :: Nat -> Nat+          f y = Succ y+        in f x+    foo5 :: Nat -> Nat+    foo5 x+      = let+          f :: Nat -> Nat+          f y+            = let+                z :: Nat+                z = Succ y+              in Succ z+        in f x+    foo6 :: Nat -> Nat+    foo6 x+      = let+          f :: Nat -> Nat+          f y = Succ y in+        let+          z :: Nat+          z = f x+        in z+    foo7 :: Nat -> Nat+    foo7 x+      = let+          x :: Nat+          x = Zero+        in x+    foo8 :: Nat -> Nat+    foo8 x+      = let+          z :: Nat+          z = (\ x -> x) Zero+        in z+    foo9 :: Nat -> Nat+    foo9 x+      = let+          z :: Nat -> Nat+          z = \ x -> x+        in z x+    foo10 :: Nat -> Nat+    foo10 x+      = let+          (+) :: Nat -> Nat -> Nat+          (+) Zero m = m+          (+) (Succ n) m = Succ (n + m)+        in (Succ Zero + x)+    foo11 :: Nat -> Nat+    foo11 x+      = let+          (+) :: Nat -> Nat -> Nat+          z :: Nat+          (+) Zero m = m+          (+) (Succ n) m = Succ (n + m)+          z = x+        in (Succ Zero + z)+    foo12 :: Nat -> Nat+    foo12 x+      = let+          (+) :: Nat -> Nat -> Nat+          (+) Zero m = m+          (+) (Succ n) m = Succ (n + x)+        in (x + Succ (Succ Zero))+    foo13 :: forall a. a -> a+    foo13 x+      = let+          bar :: a+          bar = x+        in foo13_ bar+    foo13_ :: a -> a+    foo13_ y = y+    foo14 :: Nat -> (Nat, Nat)+    foo14 x = let (y, z) = (Succ x, x) in (z, y)+    type family Case_0123456789876543210 x t where+      Case_0123456789876543210 x '(_,+                                   y_0123456789876543210) = y_0123456789876543210+    type family Case_0123456789876543210 x t where+      Case_0123456789876543210 x '(y_0123456789876543210,+                                   _) = y_0123456789876543210+    type Let0123456789876543210ZSym1 x0123456789876543210 =+        Let0123456789876543210Z x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym0KindInference) ())+    data Let0123456789876543210ZSym0 x0123456789876543210+      where+        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>+                                                    Let0123456789876543210ZSym0 x0123456789876543210+    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210+    type Let0123456789876543210YSym1 x0123456789876543210 =+        Let0123456789876543210Y x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210YSym0KindInference) ())+    data Let0123456789876543210YSym0 x0123456789876543210+      where+        Let0123456789876543210YSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>+                                                    Let0123456789876543210YSym0 x0123456789876543210+    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210+    type Let0123456789876543210X_0123456789876543210Sym1 x0123456789876543210 =+        Let0123456789876543210X_0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210X_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,) Let0123456789876543210X_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210+      where+        Let0123456789876543210X_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                                               arg. SameKind (Apply Let0123456789876543210X_0123456789876543210Sym0 arg) (Let0123456789876543210X_0123456789876543210Sym1 arg) =>+                                                                        Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Let0123456789876543210X_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210X_0123456789876543210 x0123456789876543210+    type family Let0123456789876543210Z x where+      Let0123456789876543210Z x = Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)+    type family Let0123456789876543210Y x where+      Let0123456789876543210Y x = Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x)+    type family Let0123456789876543210X_0123456789876543210 x where+      Let0123456789876543210X_0123456789876543210 x = Apply (Apply Tuple2Sym0 (Apply SuccSym0 x)) x+    type Let0123456789876543210BarSym1 x0123456789876543210 =+        Let0123456789876543210Bar x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210BarSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210BarSym0KindInference) ())+    data Let0123456789876543210BarSym0 x0123456789876543210+      where+        Let0123456789876543210BarSym0KindInference :: forall x0123456789876543210+                                                             arg. SameKind (Apply Let0123456789876543210BarSym0 arg) (Let0123456789876543210BarSym1 arg) =>+                                                      Let0123456789876543210BarSym0 x0123456789876543210+    type instance Apply Let0123456789876543210BarSym0 x0123456789876543210 = Let0123456789876543210Bar x0123456789876543210+    type family Let0123456789876543210Bar x :: a where+      Let0123456789876543210Bar x = x+    type (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: forall x0123456789876543210+                                                      a0123456789876543210+                                                      a0123456789876543210+                                                      arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>+                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210+    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) a0123456789876543210 x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: forall x0123456789876543210+                                                     a0123456789876543210+                                                     arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>+                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210+    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: forall x0123456789876543210+                                                    arg. SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>+                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210+    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210+    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (a :: Nat) (a :: Nat) :: Nat where+      (<<<%%%%%%%%%%%%%%%%%%%%) x 'Zero m = m+      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) n) x)+    type Let0123456789876543210ZSym1 x0123456789876543210 =+        Let0123456789876543210Z x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym0KindInference) ())+    data Let0123456789876543210ZSym0 x0123456789876543210+      where+        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>+                                                    Let0123456789876543210ZSym0 x0123456789876543210+    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210+    type (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: forall x0123456789876543210+                                                      a0123456789876543210+                                                      a0123456789876543210+                                                      arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>+                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210+    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) a0123456789876543210 x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: forall x0123456789876543210+                                                     a0123456789876543210+                                                     arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>+                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210+    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: forall x0123456789876543210+                                                    arg. SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>+                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210+    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210+    type family Let0123456789876543210Z x :: Nat where+      Let0123456789876543210Z x = x+    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (a :: Nat) (a :: Nat) :: Nat where+      (<<<%%%%%%%%%%%%%%%%%%%%) x 'Zero m = m+      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) n) m)+    type (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        (<<<%%%%%%%%%%%%%%%%%%%%) x0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 (a0123456789876543210 :: Nat) :: (~>) Nat Nat+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$$###) :: forall x0123456789876543210+                                                      a0123456789876543210+                                                      a0123456789876543210+                                                      arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$$) x0123456789876543210 a0123456789876543210 arg) =>+                                               (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210 a0123456789876543210+    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) a0123456789876543210 x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%) a0123456789876543210 x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 :: (~>) Nat ((~>) Nat Nat)+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$$###) :: forall x0123456789876543210+                                                     a0123456789876543210+                                                     arg. SameKind (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 arg) =>+                                              (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210 a0123456789876543210+    type instance Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210) a0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$$) x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (<<<%%%%%%%%%%%%%%%%%%%%@#@$) where+      suppressUnusedWarnings+        = snd (((,) (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###)) ())+    data (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210+      where+        (:<<<%%%%%%%%%%%%%%%%%%%%@#@$###) :: forall x0123456789876543210+                                                    arg. SameKind (Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) arg) ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) arg) =>+                                             (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210+    type instance Apply (<<<%%%%%%%%%%%%%%%%%%%%@#@$) x0123456789876543210 = (<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x0123456789876543210+    type family (<<<%%%%%%%%%%%%%%%%%%%%) x (a :: Nat) (a :: Nat) :: Nat where+      (<<<%%%%%%%%%%%%%%%%%%%%) x 'Zero m = m+      (<<<%%%%%%%%%%%%%%%%%%%%) x ('Succ n) m = Apply SuccSym0 (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) n) m)+    type family Lambda_0123456789876543210 a_0123456789876543210 x t where+      Lambda_0123456789876543210 a_0123456789876543210 x x = x+    type Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 x0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 a_01234567898765432100123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall a_01234567898765432100123456789876543210+                                                              x0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a_01234567898765432100123456789876543210 x0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 x0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 x0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall a_01234567898765432100123456789876543210+                                                              x0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall a_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210+    type Let0123456789876543210ZSym2 x0123456789876543210 (a0123456789876543210 :: Nat) =+        Let0123456789876543210Z x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym1KindInference) ())+    data Let0123456789876543210ZSym1 x0123456789876543210 :: (~>) Nat Nat+      where+        Let0123456789876543210ZSym1KindInference :: forall x0123456789876543210+                                                           a0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210ZSym1 x0123456789876543210) arg) (Let0123456789876543210ZSym2 x0123456789876543210 arg) =>+                                                    Let0123456789876543210ZSym1 x0123456789876543210 a0123456789876543210+    type instance Apply (Let0123456789876543210ZSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210Z x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym0KindInference) ())+    data Let0123456789876543210ZSym0 x0123456789876543210+      where+        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>+                                                    Let0123456789876543210ZSym0 x0123456789876543210+    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210ZSym1 x0123456789876543210+    type family Let0123456789876543210Z x (a :: Nat) :: Nat where+      Let0123456789876543210Z x a_0123456789876543210 = Apply (Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) x) a_0123456789876543210+    type family Lambda_0123456789876543210 x t where+      Lambda_0123456789876543210 x x = x+    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type Let0123456789876543210ZSym1 x0123456789876543210 =+        Let0123456789876543210Z x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym0KindInference) ())+    data Let0123456789876543210ZSym0 x0123456789876543210+      where+        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>+                                                    Let0123456789876543210ZSym0 x0123456789876543210+    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210+    type family Let0123456789876543210Z x :: Nat where+      Let0123456789876543210Z x = Apply (Apply Lambda_0123456789876543210Sym0 x) ZeroSym0+    type Let0123456789876543210XSym1 x0123456789876543210 =+        Let0123456789876543210X x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210XSym0KindInference) ())+    data Let0123456789876543210XSym0 x0123456789876543210+      where+        Let0123456789876543210XSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>+                                                    Let0123456789876543210XSym0 x0123456789876543210+    type instance Apply Let0123456789876543210XSym0 x0123456789876543210 = Let0123456789876543210X x0123456789876543210+    type family Let0123456789876543210X x :: Nat where+      Let0123456789876543210X x = ZeroSym0+    type Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) =+        Let0123456789876543210F x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210FSym1KindInference) ())+    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat+      where+        Let0123456789876543210FSym1KindInference :: forall x0123456789876543210+                                                           a0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>+                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210+    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210FSym0KindInference) ())+    data Let0123456789876543210FSym0 x0123456789876543210+      where+        Let0123456789876543210FSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>+                                                    Let0123456789876543210FSym0 x0123456789876543210+    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210+    type family Let0123456789876543210F x (a :: Nat) :: Nat where+      Let0123456789876543210F x y = Apply SuccSym0 y+    type Let0123456789876543210ZSym1 x0123456789876543210 =+        Let0123456789876543210Z x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym0KindInference) ())+    data Let0123456789876543210ZSym0 x0123456789876543210+      where+        Let0123456789876543210ZSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>+                                                    Let0123456789876543210ZSym0 x0123456789876543210+    type instance Apply Let0123456789876543210ZSym0 x0123456789876543210 = Let0123456789876543210Z x0123456789876543210+    type family Let0123456789876543210Z x :: Nat where+      Let0123456789876543210Z x = Apply (Let0123456789876543210FSym1 x) x+    type Let0123456789876543210ZSym2 y0123456789876543210 x0123456789876543210 =+        Let0123456789876543210Z y0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210ZSym1 y0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym1KindInference) ())+    data Let0123456789876543210ZSym1 y0123456789876543210 x0123456789876543210+      where+        Let0123456789876543210ZSym1KindInference :: forall y0123456789876543210+                                                           x0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210ZSym1 y0123456789876543210) arg) (Let0123456789876543210ZSym2 y0123456789876543210 arg) =>+                                                    Let0123456789876543210ZSym1 y0123456789876543210 x0123456789876543210+    type instance Apply (Let0123456789876543210ZSym1 y0123456789876543210) x0123456789876543210 = Let0123456789876543210Z y0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210ZSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210ZSym0KindInference) ())+    data Let0123456789876543210ZSym0 y0123456789876543210+      where+        Let0123456789876543210ZSym0KindInference :: forall y0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210ZSym0 arg) (Let0123456789876543210ZSym1 arg) =>+                                                    Let0123456789876543210ZSym0 y0123456789876543210+    type instance Apply Let0123456789876543210ZSym0 y0123456789876543210 = Let0123456789876543210ZSym1 y0123456789876543210+    type family Let0123456789876543210Z y x :: Nat where+      Let0123456789876543210Z y x = Apply SuccSym0 y+    type Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) =+        Let0123456789876543210F x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210FSym1KindInference) ())+    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat+      where+        Let0123456789876543210FSym1KindInference :: forall x0123456789876543210+                                                           a0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>+                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210+    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210FSym0KindInference) ())+    data Let0123456789876543210FSym0 x0123456789876543210+      where+        Let0123456789876543210FSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>+                                                    Let0123456789876543210FSym0 x0123456789876543210+    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210+    type family Let0123456789876543210F x (a :: Nat) :: Nat where+      Let0123456789876543210F x y = Apply SuccSym0 (Let0123456789876543210ZSym2 y x)+    type Let0123456789876543210FSym2 x0123456789876543210 (a0123456789876543210 :: Nat) =+        Let0123456789876543210F x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210FSym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210FSym1KindInference) ())+    data Let0123456789876543210FSym1 x0123456789876543210 :: (~>) Nat Nat+      where+        Let0123456789876543210FSym1KindInference :: forall x0123456789876543210+                                                           a0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210FSym1 x0123456789876543210) arg) (Let0123456789876543210FSym2 x0123456789876543210 arg) =>+                                                    Let0123456789876543210FSym1 x0123456789876543210 a0123456789876543210+    type instance Apply (Let0123456789876543210FSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210F x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210FSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210FSym0KindInference) ())+    data Let0123456789876543210FSym0 x0123456789876543210+      where+        Let0123456789876543210FSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210FSym0 arg) (Let0123456789876543210FSym1 arg) =>+                                                    Let0123456789876543210FSym0 x0123456789876543210+    type instance Apply Let0123456789876543210FSym0 x0123456789876543210 = Let0123456789876543210FSym1 x0123456789876543210+    type family Let0123456789876543210F x (a :: Nat) :: Nat where+      Let0123456789876543210F x y = Apply SuccSym0 y+    type Let0123456789876543210YSym1 x0123456789876543210 =+        Let0123456789876543210Y x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210YSym0KindInference) ())+    data Let0123456789876543210YSym0 x0123456789876543210+      where+        Let0123456789876543210YSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>+                                                    Let0123456789876543210YSym0 x0123456789876543210+    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210+    type family Let0123456789876543210Y x :: Nat where+      Let0123456789876543210Y x = Apply SuccSym0 x+    type Let0123456789876543210ZSym0 = Let0123456789876543210Z+    type Let0123456789876543210YSym0 = Let0123456789876543210Y+    type family Let0123456789876543210Z where+      Let0123456789876543210Z = Apply SuccSym0 Let0123456789876543210YSym0+    type family Let0123456789876543210Y where+      Let0123456789876543210Y = Apply SuccSym0 ZeroSym0+    type Let0123456789876543210YSym1 x0123456789876543210 =+        Let0123456789876543210Y x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210YSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210YSym0KindInference) ())+    data Let0123456789876543210YSym0 x0123456789876543210+      where+        Let0123456789876543210YSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210YSym0 arg) (Let0123456789876543210YSym1 arg) =>+                                                    Let0123456789876543210YSym0 x0123456789876543210+    type instance Apply Let0123456789876543210YSym0 x0123456789876543210 = Let0123456789876543210Y x0123456789876543210+    type family Let0123456789876543210Y x :: Nat where+      Let0123456789876543210Y x = Apply SuccSym0 ZeroSym0+    type Foo14Sym1 (a0123456789876543210 :: Nat) =+        Foo14 a0123456789876543210+    instance SuppressUnusedWarnings Foo14Sym0 where+      suppressUnusedWarnings = snd (((,) Foo14Sym0KindInference) ())+    data Foo14Sym0 :: (~>) Nat (Nat, Nat)+      where+        Foo14Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply Foo14Sym0 arg) (Foo14Sym1 arg) =>+                                  Foo14Sym0 a0123456789876543210+    type instance Apply Foo14Sym0 a0123456789876543210 = Foo14 a0123456789876543210+    type Foo13_Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Foo13_ a0123456789876543210+    instance SuppressUnusedWarnings Foo13_Sym0 where+      suppressUnusedWarnings = snd (((,) Foo13_Sym0KindInference) ())+    data Foo13_Sym0 :: forall a0123456789876543210.+                       (~>) a0123456789876543210 a0123456789876543210+      where+        Foo13_Sym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply Foo13_Sym0 arg) (Foo13_Sym1 arg) =>+                                   Foo13_Sym0 a0123456789876543210+    type instance Apply Foo13_Sym0 a0123456789876543210 = Foo13_ a0123456789876543210+    type Foo13Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Foo13 a0123456789876543210+    instance SuppressUnusedWarnings Foo13Sym0 where+      suppressUnusedWarnings = snd (((,) Foo13Sym0KindInference) ())+    data Foo13Sym0 :: forall a0123456789876543210.+                      (~>) a0123456789876543210 a0123456789876543210+      where+        Foo13Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply Foo13Sym0 arg) (Foo13Sym1 arg) =>+                                  Foo13Sym0 a0123456789876543210+    type instance Apply Foo13Sym0 a0123456789876543210 = Foo13 a0123456789876543210+    type Foo12Sym1 (a0123456789876543210 :: Nat) =+        Foo12 a0123456789876543210+    instance SuppressUnusedWarnings Foo12Sym0 where+      suppressUnusedWarnings = snd (((,) Foo12Sym0KindInference) ())+    data Foo12Sym0 :: (~>) Nat Nat+      where+        Foo12Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply Foo12Sym0 arg) (Foo12Sym1 arg) =>+                                  Foo12Sym0 a0123456789876543210+    type instance Apply Foo12Sym0 a0123456789876543210 = Foo12 a0123456789876543210+    type Foo11Sym1 (a0123456789876543210 :: Nat) =+        Foo11 a0123456789876543210+    instance SuppressUnusedWarnings Foo11Sym0 where+      suppressUnusedWarnings = snd (((,) Foo11Sym0KindInference) ())+    data Foo11Sym0 :: (~>) Nat Nat+      where+        Foo11Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply Foo11Sym0 arg) (Foo11Sym1 arg) =>+                                  Foo11Sym0 a0123456789876543210+    type instance Apply Foo11Sym0 a0123456789876543210 = Foo11 a0123456789876543210+    type Foo10Sym1 (a0123456789876543210 :: Nat) =+        Foo10 a0123456789876543210+    instance SuppressUnusedWarnings Foo10Sym0 where+      suppressUnusedWarnings = snd (((,) Foo10Sym0KindInference) ())+    data Foo10Sym0 :: (~>) Nat Nat+      where+        Foo10Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply Foo10Sym0 arg) (Foo10Sym1 arg) =>+                                  Foo10Sym0 a0123456789876543210+    type instance Apply Foo10Sym0 a0123456789876543210 = Foo10 a0123456789876543210+    type Foo9Sym1 (a0123456789876543210 :: Nat) =+        Foo9 a0123456789876543210+    instance SuppressUnusedWarnings Foo9Sym0 where+      suppressUnusedWarnings = snd (((,) Foo9Sym0KindInference) ())+    data Foo9Sym0 :: (~>) Nat Nat+      where+        Foo9Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo9Sym0 arg) (Foo9Sym1 arg) =>+                                 Foo9Sym0 a0123456789876543210+    type instance Apply Foo9Sym0 a0123456789876543210 = Foo9 a0123456789876543210+    type Foo8Sym1 (a0123456789876543210 :: Nat) =+        Foo8 a0123456789876543210+    instance SuppressUnusedWarnings Foo8Sym0 where+      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())+    data Foo8Sym0 :: (~>) Nat Nat+      where+        Foo8Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>+                                 Foo8Sym0 a0123456789876543210+    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210+    type Foo7Sym1 (a0123456789876543210 :: Nat) =+        Foo7 a0123456789876543210+    instance SuppressUnusedWarnings Foo7Sym0 where+      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())+    data Foo7Sym0 :: (~>) Nat Nat+      where+        Foo7Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>+                                 Foo7Sym0 a0123456789876543210+    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7 a0123456789876543210+    type Foo6Sym1 (a0123456789876543210 :: Nat) =+        Foo6 a0123456789876543210+    instance SuppressUnusedWarnings Foo6Sym0 where+      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())+    data Foo6Sym0 :: (~>) Nat Nat+      where+        Foo6Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>+                                 Foo6Sym0 a0123456789876543210+    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6 a0123456789876543210+    type Foo5Sym1 (a0123456789876543210 :: Nat) =+        Foo5 a0123456789876543210+    instance SuppressUnusedWarnings Foo5Sym0 where+      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())+    data Foo5Sym0 :: (~>) Nat Nat+      where+        Foo5Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>+                                 Foo5Sym0 a0123456789876543210+    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210+    type Foo4Sym1 (a0123456789876543210 :: Nat) =+        Foo4 a0123456789876543210+    instance SuppressUnusedWarnings Foo4Sym0 where+      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())+    data Foo4Sym0 :: (~>) Nat Nat+      where+        Foo4Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>+                                 Foo4Sym0 a0123456789876543210+    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210+    type Foo3Sym1 (a0123456789876543210 :: Nat) =+        Foo3 a0123456789876543210+    instance SuppressUnusedWarnings Foo3Sym0 where+      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())+    data Foo3Sym0 :: (~>) Nat Nat+      where+        Foo3Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>+                                 Foo3Sym0 a0123456789876543210+    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210+    type Foo2Sym0 = Foo2+    type Foo1Sym1 (a0123456789876543210 :: Nat) =+        Foo1 a0123456789876543210+    instance SuppressUnusedWarnings Foo1Sym0 where+      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())+    data Foo1Sym0 :: (~>) Nat Nat+      where+        Foo1Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>+                                 Foo1Sym0 a0123456789876543210+    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210+    type family Foo14 (a :: Nat) :: (Nat, Nat) where+      Foo14 x = Apply (Apply Tuple2Sym0 (Let0123456789876543210ZSym1 x)) (Let0123456789876543210YSym1 x)+    type family Foo13_ (a :: a) :: a where+      Foo13_ y = y+    type family Foo13 (a :: a) :: a where+      Foo13 x = Apply Foo13_Sym0 (Let0123456789876543210BarSym1 x)+    type family Foo12 (a :: Nat) :: Nat where+      Foo12 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))+    type family Foo11 (a :: Nat) :: Nat where+      Foo11 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789876543210ZSym1 x)+    type family Foo10 (a :: Nat) :: Nat where+      Foo10 x = Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) (Apply SuccSym0 ZeroSym0)) x+    type family Foo9 (a :: Nat) :: Nat where+      Foo9 x = Apply (Let0123456789876543210ZSym1 x) x+    type family Foo8 (a :: Nat) :: Nat where+      Foo8 x = Let0123456789876543210ZSym1 x+    type family Foo7 (a :: Nat) :: Nat where+      Foo7 x = Let0123456789876543210XSym1 x+    type family Foo6 (a :: Nat) :: Nat where+      Foo6 x = Let0123456789876543210ZSym1 x+    type family Foo5 (a :: Nat) :: Nat where+      Foo5 x = Apply (Let0123456789876543210FSym1 x) x+    type family Foo4 (a :: Nat) :: Nat where+      Foo4 x = Apply (Let0123456789876543210FSym1 x) x+    type family Foo3 (a :: Nat) :: Nat where+      Foo3 x = Let0123456789876543210YSym1 x+    type family Foo2 :: Nat where+      Foo2 = Let0123456789876543210ZSym0+    type family Foo1 (a :: Nat) :: Nat where+      Foo1 x = Let0123456789876543210YSym1 x+    sFoo14 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo14Sym0 t :: (Nat, Nat))+    sFoo13_ ::+      forall a (t :: a). Sing t -> Sing (Apply Foo13_Sym0 t :: a)+    sFoo13 ::+      forall a (t :: a). Sing t -> Sing (Apply Foo13Sym0 t :: a)+    sFoo12 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo12Sym0 t :: Nat)+    sFoo11 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo11Sym0 t :: Nat)+    sFoo10 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo10Sym0 t :: Nat)+    sFoo9 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo9Sym0 t :: Nat)+    sFoo8 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo8Sym0 t :: Nat)+    sFoo7 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo7Sym0 t :: Nat)+    sFoo6 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo6Sym0 t :: Nat)+    sFoo5 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo5Sym0 t :: Nat)+    sFoo4 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo4Sym0 t :: Nat)+    sFoo3 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo3Sym0 t :: Nat)+    sFoo2 :: Sing (Foo2Sym0 :: Nat)+    sFoo1 ::+      forall (t :: Nat). Sing t -> Sing (Apply Foo1Sym0 t :: Nat)+    sFoo14 (sX :: Sing x)+      = let+          sZ :: Sing (Let0123456789876543210ZSym1 x)+          sY :: Sing (Let0123456789876543210YSym1 x)+          sX_0123456789876543210 ::+            Sing (Let0123456789876543210X_0123456789876543210Sym1 x)+          sZ+            = (id+                 @(Sing (Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x))))+                (case sX_0123456789876543210 of {+                   STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210)+                     -> sY_0123456789876543210 })+          sY+            = (id+                 @(Sing (Case_0123456789876543210 x (Let0123456789876543210X_0123456789876543210Sym1 x))))+                (case sX_0123456789876543210 of {+                   STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _+                     -> sY_0123456789876543210 })+          sX_0123456789876543210+            = (applySing+                 ((applySing ((singFun2 @Tuple2Sym0) STuple2))+                    ((applySing ((singFun1 @SuccSym0) SSucc)) sX)))+                sX+        in (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sZ)) sY+    sFoo13_ (sY :: Sing y) = sY+    sFoo13 (sX :: Sing x)+      = let+          sBar :: Sing (Let0123456789876543210BarSym1 x :: a)+          sBar = sX+        in (applySing ((singFun1 @Foo13_Sym0) sFoo13_)) sBar+    sFoo12 (sX :: Sing x)+      = let+          (%+) ::+            forall (t :: Nat) (t :: Nat).+            Sing t+            -> Sing t+               -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)+          (%+) SZero (sM :: Sing m) = sM+          (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)+            = (applySing ((singFun1 @SuccSym0) SSucc))+                ((applySing+                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))+                       sN))+                   sX)+        in+          (applySing+             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))+                sX))+            ((applySing ((singFun1 @SuccSym0) SSucc))+               ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))+    sFoo11 (sX :: Sing x)+      = let+          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)+          (%+) ::+            forall (t :: Nat) (t :: Nat).+            Sing t+            -> Sing t+               -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)+          sZ = sX+          (%+) SZero (sM :: Sing m) = sM+          (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)+            = (applySing ((singFun1 @SuccSym0) SSucc))+                ((applySing+                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))+                       sN))+                   sM)+        in+          (applySing+             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))+                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+            sZ+    sFoo10 (sX :: Sing x)+      = let+          (%+) ::+            forall (t :: Nat) (t :: Nat).+            Sing t+            -> Sing t+               -> Sing (Apply (Apply ((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x) t) t :: Nat)+          (%+) SZero (sM :: Sing m) = sM+          (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)+            = (applySing ((singFun1 @SuccSym0) SSucc))+                ((applySing+                    ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))+                       sN))+                   sM)+        in+          (applySing+             ((applySing ((singFun2 @((<<<%%%%%%%%%%%%%%%%%%%%@#@$$) x)) (%+)))+                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+            sX+    sFoo9 (sX :: Sing x)+      = let+          sZ ::+            forall (t :: Nat).+            Sing t -> Sing (Apply (Let0123456789876543210ZSym1 x) t :: Nat)+          sZ (sA_0123456789876543210 :: Sing a_0123456789876543210)+            = (applySing+                 ((singFun1+                     @(Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) x))+                    (\ sX -> case sX of { (_ :: Sing x) -> sX })))+                sA_0123456789876543210+        in (applySing ((singFun1 @(Let0123456789876543210ZSym1 x)) sZ)) sX+    sFoo8 (sX :: Sing x)+      = let+          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)+          sZ+            = (applySing+                 ((singFun1 @(Apply Lambda_0123456789876543210Sym0 x))+                    (\ sX -> case sX of { (_ :: Sing x) -> sX })))+                SZero+        in sZ+    sFoo7 (sX :: Sing x)+      = let+          sX :: Sing (Let0123456789876543210XSym1 x :: Nat)+          sX = SZero+        in sX+    sFoo6 (sX :: Sing x)+      = let+          sF ::+            forall (t :: Nat).+            Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)+          sF (sY :: Sing y) = (applySing ((singFun1 @SuccSym0) SSucc)) sY in+        let+          sZ :: Sing (Let0123456789876543210ZSym1 x :: Nat)+          sZ+            = (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX+        in sZ+    sFoo5 (sX :: Sing x)+      = let+          sF ::+            forall (t :: Nat).+            Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)+          sF (sY :: Sing y)+            = let+                sZ :: Sing (Let0123456789876543210ZSym2 y x :: Nat)+                sZ = (applySing ((singFun1 @SuccSym0) SSucc)) sY+              in (applySing ((singFun1 @SuccSym0) SSucc)) sZ+        in (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX+    sFoo4 (sX :: Sing x)+      = let+          sF ::+            forall (t :: Nat).+            Sing t -> Sing (Apply (Let0123456789876543210FSym1 x) t :: Nat)+          sF (sY :: Sing y) = (applySing ((singFun1 @SuccSym0) SSucc)) sY+        in (applySing ((singFun1 @(Let0123456789876543210FSym1 x)) sF)) sX+    sFoo3 (sX :: Sing x)+      = let+          sY :: Sing (Let0123456789876543210YSym1 x :: Nat)+          sY = (applySing ((singFun1 @SuccSym0) SSucc)) sX+        in sY+    sFoo2+      = let+          sZ :: Sing Let0123456789876543210ZSym0+          sY :: Sing Let0123456789876543210YSym0+          sZ = (applySing ((singFun1 @SuccSym0) SSucc)) sY+          sY = (applySing ((singFun1 @SuccSym0) SSucc)) SZero+        in sZ+    sFoo1 (sX :: Sing x)+      = let+          sY :: Sing (Let0123456789876543210YSym1 x :: Nat)+          sY = (applySing ((singFun1 @SuccSym0) SSucc)) SZero+        in sY+    instance SingI (Foo14Sym0 :: (~>) Nat (Nat, Nat)) where+      sing = (singFun1 @Foo14Sym0) sFoo14+    instance SingI (Foo13_Sym0 :: (~>) a a) where+      sing = (singFun1 @Foo13_Sym0) sFoo13_+    instance SingI (Foo13Sym0 :: (~>) a a) where+      sing = (singFun1 @Foo13Sym0) sFoo13+    instance SingI (Foo12Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo12Sym0) sFoo12+    instance SingI (Foo11Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo11Sym0) sFoo11+    instance SingI (Foo10Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo10Sym0) sFoo10+    instance SingI (Foo9Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo9Sym0) sFoo9+    instance SingI (Foo8Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo8Sym0) sFoo8+    instance SingI (Foo7Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo7Sym0) sFoo7+    instance SingI (Foo6Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo6Sym0) sFoo6+    instance SingI (Foo5Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo5Sym0) sFoo5+    instance SingI (Foo4Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo4Sym0) sFoo4+    instance SingI (Foo3Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo3Sym0) sFoo3+    instance SingI (Foo1Sym0 :: (~>) Nat Nat) where+      sing = (singFun1 @Foo1Sym0) sFoo1
− tests/compile-and-dump/Singletons/Maybe.ghc86.template 
@@ -1,140 +0,0 @@-Singletons/Maybe.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Maybe a-            = Nothing | Just a-            deriving (Eq, Show) |]-  ======>-    data Maybe a-      = Nothing | Just a-      deriving (Eq, Show)-    type NothingSym0 = Nothing-    type JustSym1 (t0123456789876543210 :: a0123456789876543210) =-        Just t0123456789876543210-    instance SuppressUnusedWarnings JustSym0 where-      suppressUnusedWarnings = snd (((,) JustSym0KindInference) ())-    data JustSym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 (Maybe a0123456789876543210)-      where-        JustSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply JustSym0 arg) (JustSym1 arg) =>-                                 JustSym0 t0123456789876543210-    type instance Apply JustSym0 t0123456789876543210 = Just t0123456789876543210-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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) (Data.Singletons.Prelude.Num.FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Just ")) (Apply (Apply ShowsPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210-    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Maybe a0123456789876543210) (a0123456789876543210 :: GHC.Types.Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Maybe a0123456789876543210) :: (~>) GHC.Types.Symbol GHC.Types.Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.-                                                                                      (~>) (Maybe a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.-                                              (~>) GHC.Types.Nat ((~>) (Maybe a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow (Maybe a) where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family Equals_0123456789876543210 (a :: Maybe a) (b :: Maybe a) :: Bool where-      Equals_0123456789876543210 Nothing Nothing = TrueSym0-      Equals_0123456789876543210 (Just a) (Just b) = (==) a b-      Equals_0123456789876543210 (_ :: Maybe a) (_ :: Maybe a) = FalseSym0-    instance PEq (Maybe a) where-      type (==) a b = Equals_0123456789876543210 a b-    data instance Sing :: Maybe a -> GHC.Types.Type-      where-        SNothing :: Sing Nothing-        SJust :: forall a (n :: a). (Sing (n :: a)) -> Sing (Just n)-    type SMaybe = (Sing :: Maybe a -> GHC.Types.Type)-    instance SingKind a => SingKind (Maybe a) where-      type Demote (Maybe a) = Maybe (Demote a)-      fromSing SNothing = Nothing-      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) }-    instance SShow a => SShow (Maybe a) where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat)-               (t2 :: Maybe a)-               (t3 :: GHC.Types.Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        _-        SNothing-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "Nothing")))-            sA_0123456789876543210-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SJust (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "Just "))))-                   ((applySing-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                          (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 11))))-                      sArg_0123456789876543210))))-            sA_0123456789876543210-    instance SEq a => SEq (Maybe a) where-      (%==) SNothing SNothing = STrue-      (%==) SNothing (SJust _) = SFalse-      (%==) (SJust _) SNothing = SFalse-      (%==) (SJust a) (SJust b) = ((%==) a) b-    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)-      (%~) (SJust a) (SJust b)-        = case ((%~) a) b of-            Proved Refl -> Proved Refl-            Disproved contra-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-    deriving instance Data.Singletons.ShowSing.ShowSing a =>-                      Show (Sing (z :: Maybe a))-    instance SingI Nothing where-      sing = SNothing-    instance SingI n => SingI (Just (n :: a)) where-      sing = SJust sing-    instance SingI (JustSym0 :: (~>) a (Maybe a)) where-      sing = (singFun1 @JustSym0) SJust-    instance SingI (TyCon1 Just :: (~>) a (Maybe a)) where-      sing = (singFun1 @(TyCon1 Just)) SJust
+ tests/compile-and-dump/Singletons/Maybe.ghc88.template view
@@ -0,0 +1,157 @@+Singletons/Maybe.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Maybe a+            = Nothing | Just a+            deriving (Eq, Show) |]+  ======>+    data Maybe a+      = Nothing | Just a+      deriving (Eq, Show)+    type NothingSym0 = Nothing+    type JustSym1 (t0123456789876543210 :: a0123456789876543210) =+        Just t0123456789876543210+    instance SuppressUnusedWarnings JustSym0 where+      suppressUnusedWarnings = snd (((,) JustSym0KindInference) ())+    data JustSym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 (Maybe a0123456789876543210)+      where+        JustSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply JustSym0 arg) (JustSym1 arg) =>+                                 JustSym0 t0123456789876543210+    type instance Apply JustSym0 t0123456789876543210 = Just t0123456789876543210+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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) (Data.Singletons.Prelude.Num.FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Just ")) (Apply (Apply ShowsPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210+    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Maybe a0123456789876543210) (a0123456789876543210 :: GHC.Types.Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Maybe a0123456789876543210) :: (~>) GHC.Types.Symbol GHC.Types.Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.+                                                                                      (~>) (Maybe a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.+                                              (~>) GHC.Types.Nat ((~>) (Maybe a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow (Maybe a) where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family Equals_0123456789876543210 (a :: Maybe a) (b :: Maybe a) :: Bool where+      Equals_0123456789876543210 Nothing Nothing = TrueSym0+      Equals_0123456789876543210 (Just a) (Just b) = (==) a b+      Equals_0123456789876543210 (_ :: Maybe a) (_ :: Maybe a) = FalseSym0+    instance PEq (Maybe a) where+      type (==) a b = Equals_0123456789876543210 a b+    data SMaybe :: forall a. Maybe a -> GHC.Types.Type+      where+        SNothing :: SMaybe Nothing+        SJust :: forall a (n :: a). (Sing (n :: a)) -> SMaybe (Just n)+    type instance Sing @(Maybe a) = SMaybe+    instance SingKind a => SingKind (Maybe a) where+      type Demote (Maybe a) = Maybe (Demote a)+      fromSing SNothing = Nothing+      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) }+    instance SShow a => SShow (Maybe a) where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat)+               (t2 :: Maybe a)+               (t3 :: GHC.Types.Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Maybe a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        _+        SNothing+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "Nothing")))+            sA_0123456789876543210+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SJust (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "Just "))))+                   ((applySing+                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                          (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 11))))+                      sArg_0123456789876543210))))+            sA_0123456789876543210+    instance SEq a => SEq (Maybe a) where+      (%==) SNothing SNothing = STrue+      (%==) SNothing (SJust _) = SFalse+      (%==) (SJust _) SNothing = SFalse+      (%==) (SJust a) (SJust b) = ((%==) a) b+    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)+      (%~) (SJust a) (SJust b)+        = case ((%~) a) b of+            Proved Refl -> Proved Refl+            Disproved contra+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+    instance SDecide a =>+             Data.Type.Equality.TestEquality (SMaybe :: Maybe a+                                                        -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance SDecide a =>+             Data.Type.Coercion.TestCoercion (SMaybe :: Maybe a+                                                        -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance Data.Singletons.ShowSing.ShowSing a =>+             Show (SMaybe (z :: Maybe a)) where+      showsPrec _ SNothing = showString "SNothing"+      showsPrec+        p_0123456789876543210+        (SJust (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SJust "))+               ((showsPrec 11) arg_0123456789876543210)) ::+            Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210 =>+            ShowS+    instance SingI Nothing where+      sing = SNothing+    instance SingI n => SingI (Just (n :: a)) where+      sing = SJust sing+    instance SingI (JustSym0 :: (~>) a (Maybe a)) where+      sing = (singFun1 @JustSym0) SJust
− tests/compile-and-dump/Singletons/Nat.ghc86.template 
@@ -1,266 +0,0 @@-Singletons/Nat.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| plus :: Nat -> Nat -> Nat-          plus Zero m = m-          plus (Succ n) m = Succ (plus n m)-          pred :: Nat -> Nat-          pred Zero = Zero-          pred (Succ n) = n-          -          data Nat-            where-              Zero :: Nat-              Succ :: Nat -> Nat-            deriving (Eq, Show, Read, Ord) |]-  ======>-    data Nat-      where-        Zero :: Nat-        Succ :: Nat -> Nat-      deriving (Eq, Show, Read, Ord)-    plus :: Nat -> Nat -> Nat-    plus Zero m = m-    plus (Succ n) m = Succ ((plus n) m)-    pred :: Nat -> Nat-    pred Zero = Zero-    pred (Succ n) = n-    type ZeroSym0 = Zero-    type SuccSym1 (t0123456789876543210 :: Nat) =-        Succ t0123456789876543210-    instance SuppressUnusedWarnings SuccSym0 where-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())-    data SuccSym0 :: (~>) Nat Nat-      where-        SuccSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>-                                 SuccSym0 t0123456789876543210-    type instance Apply SuccSym0 t0123456789876543210 = Succ t0123456789876543210-    type PredSym1 (a0123456789876543210 :: Nat) =-        Pred a0123456789876543210-    instance SuppressUnusedWarnings PredSym0 where-      suppressUnusedWarnings = snd (((,) PredSym0KindInference) ())-    data PredSym0 :: (~>) Nat Nat-      where-        PredSym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply PredSym0 arg) (PredSym1 arg) =>-                                 PredSym0 a0123456789876543210-    type instance Apply PredSym0 a0123456789876543210 = Pred a0123456789876543210-    type PlusSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        Plus a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (PlusSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) PlusSym1KindInference) ())-    data PlusSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Nat-      where-        PlusSym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (PlusSym1 a0123456789876543210) arg) (PlusSym2 a0123456789876543210 arg) =>-                                 PlusSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (PlusSym1 a0123456789876543210) a0123456789876543210 = Plus a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings PlusSym0 where-      suppressUnusedWarnings = snd (((,) PlusSym0KindInference) ())-    data PlusSym0 :: (~>) Nat ((~>) Nat Nat)-      where-        PlusSym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply PlusSym0 arg) (PlusSym1 arg) =>-                                 PlusSym0 a0123456789876543210-    type instance Apply PlusSym0 a0123456789876543210 = PlusSym1 a0123456789876543210-    type family Pred (a :: Nat) :: Nat where-      Pred Zero = ZeroSym0-      Pred (Succ n) = n-    type family Plus (a :: Nat) (a :: Nat) :: Nat where-      Plus Zero m = m-      Plus (Succ n) m = Apply SuccSym0 (Apply (Apply PlusSym0 n) m)-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Nat) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where-      ShowsPrec_0123456789876543210 _ Zero a_0123456789876543210 = Apply (Apply ShowStringSym0 "Zero") a_0123456789876543210-      ShowsPrec_0123456789876543210 p_0123456789876543210 (Succ arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (Data.Singletons.Prelude.Num.FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Succ ")) (Apply (Apply ShowsPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210-    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Nat) (a0123456789876543210 :: GHC.Types.Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Nat) :: (~>) GHC.Types.Symbol GHC.Types.Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow Nat where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where-      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])-      Compare_0123456789876543210 Zero (Succ _) = LTSym0-      Compare_0123456789876543210 (Succ _) Zero = GTSym0-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd Nat where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Equals_0123456789876543210 (a :: Nat) (b :: Nat) :: Bool where-      Equals_0123456789876543210 Zero Zero = TrueSym0-      Equals_0123456789876543210 (Succ a) (Succ b) = (==) a b-      Equals_0123456789876543210 (_ :: Nat) (_ :: Nat) = FalseSym0-    instance PEq Nat where-      type (==) a b = Equals_0123456789876543210 a b-    sPred ::-      forall (t :: Nat). Sing t -> Sing (Apply PredSym0 t :: Nat)-    sPlus ::-      forall (t :: Nat) (t :: Nat).-      Sing t -> Sing t -> Sing (Apply (Apply PlusSym0 t) t :: Nat)-    sPred SZero = SZero-    sPred (SSucc (sN :: Sing n)) = sN-    sPlus SZero (sM :: Sing m) = sM-    sPlus (SSucc (sN :: Sing n)) (sM :: Sing m)-      = (applySing ((singFun1 @SuccSym0) SSucc))-          ((applySing ((applySing ((singFun2 @PlusSym0) sPlus)) sN)) sM)-    instance SingI (PredSym0 :: (~>) Nat Nat) where-      sing = (singFun1 @PredSym0) sPred-    instance SingI (PlusSym0 :: (~>) Nat ((~>) Nat Nat)) where-      sing = (singFun2 @PlusSym0) sPlus-    instance SingI d =>-             SingI (PlusSym1 (d :: Nat) :: (~>) Nat Nat) where-      sing = (singFun1 @(PlusSym1 (d :: Nat))) (sPlus (sing @d))-    data instance Sing :: Nat -> GHC.Types.Type-      where-        SZero :: Sing Zero-        SSucc :: forall (n :: Nat). (Sing (n :: Nat)) -> Sing (Succ n)-    type SNat = (Sing :: Nat -> GHC.Types.Type)-    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 SShow Nat => SShow Nat where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Nat) (t3 :: GHC.Types.Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        _-        SZero-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "Zero")))-            sA_0123456789876543210-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SSucc (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "Succ "))))-                   ((applySing-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                          (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 11))))-                      sArg_0123456789876543210))))-            sA_0123456789876543210-    instance SOrd Nat => SOrd Nat where-      sCompare ::-        forall (t1 :: Nat) (t2 :: Nat).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)-                                                 -> GHC.Types.Type) t1) t2)-      sCompare SZero SZero-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            Data.Singletons.Prelude.Instances.SNil-      sCompare-        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing-                    ((singFun2 @(:@#@$))-                       Data.Singletons.Prelude.Instances.SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               Data.Singletons.Prelude.Instances.SNil)-      sCompare SZero (SSucc _) = SLT-      sCompare (SSucc _) SZero = SGT-    instance SEq Nat => SEq Nat where-      (%==) SZero SZero = STrue-      (%==) SZero (SSucc _) = SFalse-      (%==) (SSucc _) SZero = SFalse-      (%==) (SSucc a) (SSucc b) = ((%==) a) b-    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 })-    deriving instance Data.Singletons.ShowSing.ShowSing Nat =>-                      Show (Sing (z :: Nat))-    instance SingI Zero where-      sing = SZero-    instance SingI n => SingI (Succ (n :: Nat)) where-      sing = SSucc sing-    instance SingI (SuccSym0 :: (~>) Nat Nat) where-      sing = (singFun1 @SuccSym0) SSucc-    instance SingI (TyCon1 Succ :: (~>) Nat Nat) where-      sing = (singFun1 @(TyCon1 Succ)) SSucc
+ tests/compile-and-dump/Singletons/Nat.ghc88.template view
@@ -0,0 +1,283 @@+Singletons/Nat.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| plus :: Nat -> Nat -> Nat+          plus Zero m = m+          plus (Succ n) m = Succ (plus n m)+          pred :: Nat -> Nat+          pred Zero = Zero+          pred (Succ n) = n+          +          data Nat+            where+              Zero :: Nat+              Succ :: Nat -> Nat+            deriving (Eq, Show, Read, Ord) |]+  ======>+    data Nat+      where+        Zero :: Nat+        Succ :: Nat -> Nat+      deriving (Eq, Show, Read, Ord)+    plus :: Nat -> Nat -> Nat+    plus Zero m = m+    plus (Succ n) m = Succ ((plus n) m)+    pred :: Nat -> Nat+    pred Zero = Zero+    pred (Succ n) = n+    type ZeroSym0 = Zero+    type SuccSym1 (t0123456789876543210 :: Nat) =+        Succ t0123456789876543210+    instance SuppressUnusedWarnings SuccSym0 where+      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())+    data SuccSym0 :: (~>) Nat Nat+      where+        SuccSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>+                                 SuccSym0 t0123456789876543210+    type instance Apply SuccSym0 t0123456789876543210 = Succ t0123456789876543210+    type PredSym1 (a0123456789876543210 :: Nat) =+        Pred a0123456789876543210+    instance SuppressUnusedWarnings PredSym0 where+      suppressUnusedWarnings = snd (((,) PredSym0KindInference) ())+    data PredSym0 :: (~>) Nat Nat+      where+        PredSym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply PredSym0 arg) (PredSym1 arg) =>+                                 PredSym0 a0123456789876543210+    type instance Apply PredSym0 a0123456789876543210 = Pred a0123456789876543210+    type PlusSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        Plus a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (PlusSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) PlusSym1KindInference) ())+    data PlusSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Nat+      where+        PlusSym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (PlusSym1 a0123456789876543210) arg) (PlusSym2 a0123456789876543210 arg) =>+                                 PlusSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (PlusSym1 a0123456789876543210) a0123456789876543210 = Plus a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings PlusSym0 where+      suppressUnusedWarnings = snd (((,) PlusSym0KindInference) ())+    data PlusSym0 :: (~>) Nat ((~>) Nat Nat)+      where+        PlusSym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply PlusSym0 arg) (PlusSym1 arg) =>+                                 PlusSym0 a0123456789876543210+    type instance Apply PlusSym0 a0123456789876543210 = PlusSym1 a0123456789876543210+    type family Pred (a :: Nat) :: Nat where+      Pred Zero = ZeroSym0+      Pred (Succ n) = n+    type family Plus (a :: Nat) (a :: Nat) :: Nat where+      Plus Zero m = m+      Plus (Succ n) m = Apply SuccSym0 (Apply (Apply PlusSym0 n) m)+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Nat) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where+      ShowsPrec_0123456789876543210 _ Zero a_0123456789876543210 = Apply (Apply ShowStringSym0 "Zero") a_0123456789876543210+      ShowsPrec_0123456789876543210 p_0123456789876543210 (Succ arg_0123456789876543210) a_0123456789876543210 = Apply (Apply (Apply ShowParenSym0 (Apply (Apply (>@#@$) p_0123456789876543210) (Data.Singletons.Prelude.Num.FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Succ ")) (Apply (Apply ShowsPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210+    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Nat) (a0123456789876543210 :: GHC.Types.Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Nat) :: (~>) GHC.Types.Symbol GHC.Types.Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow Nat where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where+      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])+      Compare_0123456789876543210 Zero (Succ _) = LTSym0+      Compare_0123456789876543210 (Succ _) Zero = GTSym0+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd Nat where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family Equals_0123456789876543210 (a :: Nat) (b :: Nat) :: Bool where+      Equals_0123456789876543210 Zero Zero = TrueSym0+      Equals_0123456789876543210 (Succ a) (Succ b) = (==) a b+      Equals_0123456789876543210 (_ :: Nat) (_ :: Nat) = FalseSym0+    instance PEq Nat where+      type (==) a b = Equals_0123456789876543210 a b+    sPred ::+      forall (t :: Nat). Sing t -> Sing (Apply PredSym0 t :: Nat)+    sPlus ::+      forall (t :: Nat) (t :: Nat).+      Sing t -> Sing t -> Sing (Apply (Apply PlusSym0 t) t :: Nat)+    sPred SZero = SZero+    sPred (SSucc (sN :: Sing n)) = sN+    sPlus SZero (sM :: Sing m) = sM+    sPlus (SSucc (sN :: Sing n)) (sM :: Sing m)+      = (applySing ((singFun1 @SuccSym0) SSucc))+          ((applySing ((applySing ((singFun2 @PlusSym0) sPlus)) sN)) sM)+    instance SingI (PredSym0 :: (~>) Nat Nat) where+      sing = (singFun1 @PredSym0) sPred+    instance SingI (PlusSym0 :: (~>) Nat ((~>) Nat Nat)) where+      sing = (singFun2 @PlusSym0) sPlus+    instance SingI d =>+             SingI (PlusSym1 (d :: Nat) :: (~>) Nat Nat) where+      sing = (singFun1 @(PlusSym1 (d :: Nat))) (sPlus (sing @d))+    data SNat :: Nat -> GHC.Types.Type+      where+        SZero :: SNat Zero+        SSucc :: forall (n :: Nat). (Sing (n :: Nat)) -> SNat (Succ n)+    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 SShow Nat => SShow Nat where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Nat) (t3 :: GHC.Types.Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Nat ((~>) GHC.Types.Symbol GHC.Types.Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        _+        SZero+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "Zero")))+            sA_0123456789876543210+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SSucc (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "Succ "))))+                   ((applySing+                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                          (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 11))))+                      sArg_0123456789876543210))))+            sA_0123456789876543210+    instance SOrd Nat => SOrd Nat where+      sCompare ::+        forall (t1 :: Nat) (t2 :: Nat).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)+                                                 -> GHC.Types.Type) t1) t2)+      sCompare SZero SZero+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            Data.Singletons.Prelude.Instances.SNil+      sCompare+        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing+                    ((singFun2 @(:@#@$))+                       Data.Singletons.Prelude.Instances.SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               Data.Singletons.Prelude.Instances.SNil)+      sCompare SZero (SSucc _) = SLT+      sCompare (SSucc _) SZero = SGT+    instance SEq Nat => SEq Nat where+      (%==) SZero SZero = STrue+      (%==) SZero (SSucc _) = SFalse+      (%==) (SSucc _) SZero = SFalse+      (%==) (SSucc a) (SSucc b) = ((%==) a) b+    instance SDecide Nat => SDecide Nat where+      (%~) SZero SZero = Proved Refl+      (%~) SZero (SSucc _) = Disproved (\ x -> case x of)+      (%~) (SSucc _) SZero = Disproved (\ x -> case x of)+      (%~) (SSucc a) (SSucc b)+        = case ((%~) a) b of+            Proved Refl -> Proved Refl+            Disproved contra+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+    instance SDecide Nat =>+             Data.Type.Equality.TestEquality (SNat :: Nat+                                                      -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance SDecide Nat =>+             Data.Type.Coercion.TestCoercion (SNat :: Nat+                                                      -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance Data.Singletons.ShowSing.ShowSing Nat =>+             Show (SNat (z :: Nat)) where+      showsPrec _ SZero = showString "SZero"+      showsPrec+        p_0123456789876543210+        (SSucc (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SSucc "))+               ((showsPrec 11) arg_0123456789876543210)) ::+            Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210 =>+            ShowS+    instance SingI Zero where+      sing = SZero+    instance SingI n => SingI (Succ (n :: Nat)) where+      sing = SSucc sing+    instance SingI (SuccSym0 :: (~>) Nat Nat) where+      sing = (singFun1 @SuccSym0) SSucc
− tests/compile-and-dump/Singletons/NatSymbolReflexive.ghc86.template 
+ tests/compile-and-dump/Singletons/NatSymbolReflexive.ghc88.template view
− tests/compile-and-dump/Singletons/Operators.ghc86.template 
@@ -1,128 +0,0 @@-Singletons/Operators.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| child :: Foo -> Foo-          child FLeaf = FLeaf-          child (a :+: _) = a-          (+) :: Nat -> Nat -> Nat-          Zero + m = m-          (Succ n) + m = Succ (n + m)-          -          data Foo-            where-              FLeaf :: Foo-              (:+:) :: Foo -> Foo -> Foo |]-  ======>-    data Foo-      where-        FLeaf :: Foo-        (:+:) :: Foo -> Foo -> Foo-    child :: Foo -> Foo-    child FLeaf = FLeaf-    child (a :+: _) = a-    (+) :: Nat -> Nat -> Nat-    (+) Zero m = m-    (+) (Succ n) m = Succ (n + m)-    type FLeafSym0 = FLeaf-    type (:+:@#@$$$) (t0123456789876543210 :: Foo) (t0123456789876543210 :: Foo) =-        (:+:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:+:@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::+:@#@$$###)) ())-    data (:+:@#@$$) (t0123456789876543210 :: Foo) :: (~>) Foo Foo-      where-        (::+:@#@$$###) :: forall t0123456789876543210-                                 t0123456789876543210-                                 arg. SameKind (Apply ((:+:@#@$$) t0123456789876543210) arg) ((:+:@#@$$$) t0123456789876543210 arg) =>-                          (:+:@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:+:@#@$$) t0123456789876543210) t0123456789876543210 = (:+:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (:+:@#@$) where-      suppressUnusedWarnings = snd (((,) (::+:@#@$###)) ())-    data (:+:@#@$) :: (~>) Foo ((~>) Foo Foo)-      where-        (::+:@#@$###) :: forall t0123456789876543210-                                arg. SameKind (Apply (:+:@#@$) arg) ((:+:@#@$$) arg) =>-                         (:+:@#@$) t0123456789876543210-    type instance Apply (:+:@#@$) t0123456789876543210 = (:+:@#@$$) t0123456789876543210-    type (+@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        (+) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((+@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:+@#@$$###)) ())-    data (+@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat-      where-        (:+@#@$$###) :: forall a0123456789876543210-                               a0123456789876543210-                               arg. SameKind (Apply ((+@#@$$) a0123456789876543210) arg) ((+@#@$$$) a0123456789876543210 arg) =>-                        (+@#@$$) a0123456789876543210 a0123456789876543210-    type instance Apply ((+@#@$$) a0123456789876543210) a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (+@#@$) where-      suppressUnusedWarnings = snd (((,) (:+@#@$###)) ())-    data (+@#@$) :: (~>) Nat ((~>) Nat Nat)-      where-        (:+@#@$###) :: forall a0123456789876543210-                              arg. SameKind (Apply (+@#@$) arg) ((+@#@$$) arg) =>-                       (+@#@$) a0123456789876543210-    type instance Apply (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210-    type ChildSym1 (a0123456789876543210 :: Foo) =-        Child a0123456789876543210-    instance SuppressUnusedWarnings ChildSym0 where-      suppressUnusedWarnings = snd (((,) ChildSym0KindInference) ())-    data ChildSym0 :: (~>) Foo Foo-      where-        ChildSym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply ChildSym0 arg) (ChildSym1 arg) =>-                                  ChildSym0 a0123456789876543210-    type instance Apply ChildSym0 a0123456789876543210 = Child a0123456789876543210-    type family (+) (a :: Nat) (a :: Nat) :: Nat where-      (+)  'Zero m = m-      (+) ( 'Succ n) m = Apply SuccSym0 (Apply (Apply (+@#@$) n) m)-    type family Child (a :: Foo) :: Foo where-      Child FLeaf = FLeafSym0-      Child ((:+:) a _) = a-    (%+) ::-      forall (t :: Nat) (t :: Nat).-      Sing t -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat)-    sChild ::-      forall (t :: Foo). Sing t -> Sing (Apply ChildSym0 t :: Foo)-    (%+) SZero (sM :: Sing m) = sM-    (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)-      = (applySing ((singFun1 @SuccSym0) SSucc))-          ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sN)) sM)-    sChild SFLeaf = SFLeaf-    sChild ((:%+:) (sA :: Sing a) _) = sA-    instance SingI ((+@#@$) :: (~>) Nat ((~>) Nat Nat)) where-      sing = (singFun2 @(+@#@$)) (%+)-    instance SingI d =>-             SingI ((+@#@$$) (d :: Nat) :: (~>) Nat Nat) where-      sing = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) (sing @d))-    instance SingI (ChildSym0 :: (~>) Foo Foo) where-      sing = (singFun1 @ChildSym0) sChild-    data instance Sing :: Foo -> GHC.Types.Type-      where-        SFLeaf :: Sing FLeaf-        (:%+:) :: forall (n :: Foo) (n :: Foo).-                  (Sing (n :: Foo)) -> (Sing (n :: Foo)) -> Sing ((:+:) n n)-    type SFoo = (Sing :: Foo -> GHC.Types.Type)-    instance SingKind Foo where-      type Demote Foo = Foo-      fromSing SFLeaf = FLeaf-      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) }-    instance SingI FLeaf where-      sing = SFLeaf-    instance (SingI n, SingI n) =>-             SingI ((:+:) (n :: Foo) (n :: Foo)) where-      sing = ((:%+:) sing) sing-    instance SingI ((:+:@#@$) :: (~>) Foo ((~>) Foo Foo)) where-      sing = (singFun2 @(:+:@#@$)) (:%+:)-    instance SingI (TyCon2 (:+:) :: (~>) Foo ((~>) Foo Foo)) where-      sing = (singFun2 @(TyCon2 (:+:))) (:%+:)-    instance SingI d =>-             SingI ((:+:@#@$$) (d :: Foo) :: (~>) Foo Foo) where-      sing = (singFun1 @((:+:@#@$$) (d :: Foo))) ((:%+:) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ((:+:) (d :: Foo)) :: (~>) Foo Foo) where-      sing = (singFun1 @(TyCon1 ((:+:) (d :: Foo)))) ((:%+:) (sing @d))
+ tests/compile-and-dump/Singletons/Operators.ghc88.template view
@@ -0,0 +1,123 @@+Singletons/Operators.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| child :: Foo -> Foo+          child FLeaf = FLeaf+          child (a :+: _) = a+          (+) :: Nat -> Nat -> Nat+          Zero + m = m+          (Succ n) + m = Succ (n + m)+          +          data Foo+            where+              FLeaf :: Foo+              (:+:) :: Foo -> Foo -> Foo |]+  ======>+    data Foo+      where+        FLeaf :: Foo+        (:+:) :: Foo -> Foo -> Foo+    child :: Foo -> Foo+    child FLeaf = FLeaf+    child (a :+: _) = a+    (+) :: Nat -> Nat -> Nat+    (+) Zero m = m+    (+) (Succ n) m = Succ (n + m)+    type FLeafSym0 = FLeaf+    type (:+:@#@$$$) (t0123456789876543210 :: Foo) (t0123456789876543210 :: Foo) =+        (:+:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:+:@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::+:@#@$$###)) ())+    data (:+:@#@$$) (t0123456789876543210 :: Foo) :: (~>) Foo Foo+      where+        (::+:@#@$$###) :: forall t0123456789876543210+                                 t0123456789876543210+                                 arg. SameKind (Apply ((:+:@#@$$) t0123456789876543210) arg) ((:+:@#@$$$) t0123456789876543210 arg) =>+                          (:+:@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:+:@#@$$) t0123456789876543210) t0123456789876543210 = (:+:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (:+:@#@$) where+      suppressUnusedWarnings = snd (((,) (::+:@#@$###)) ())+    data (:+:@#@$) :: (~>) Foo ((~>) Foo Foo)+      where+        (::+:@#@$###) :: forall t0123456789876543210+                                arg. SameKind (Apply (:+:@#@$) arg) ((:+:@#@$$) arg) =>+                         (:+:@#@$) t0123456789876543210+    type instance Apply (:+:@#@$) t0123456789876543210 = (:+:@#@$$) t0123456789876543210+    type (+@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        (+) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((+@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:+@#@$$###)) ())+    data (+@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat+      where+        (:+@#@$$###) :: forall a0123456789876543210+                               a0123456789876543210+                               arg. SameKind (Apply ((+@#@$$) a0123456789876543210) arg) ((+@#@$$$) a0123456789876543210 arg) =>+                        (+@#@$$) a0123456789876543210 a0123456789876543210+    type instance Apply ((+@#@$$) a0123456789876543210) a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (+@#@$) where+      suppressUnusedWarnings = snd (((,) (:+@#@$###)) ())+    data (+@#@$) :: (~>) Nat ((~>) Nat Nat)+      where+        (:+@#@$###) :: forall a0123456789876543210+                              arg. SameKind (Apply (+@#@$) arg) ((+@#@$$) arg) =>+                       (+@#@$) a0123456789876543210+    type instance Apply (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210+    type ChildSym1 (a0123456789876543210 :: Foo) =+        Child a0123456789876543210+    instance SuppressUnusedWarnings ChildSym0 where+      suppressUnusedWarnings = snd (((,) ChildSym0KindInference) ())+    data ChildSym0 :: (~>) Foo Foo+      where+        ChildSym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply ChildSym0 arg) (ChildSym1 arg) =>+                                  ChildSym0 a0123456789876543210+    type instance Apply ChildSym0 a0123456789876543210 = Child a0123456789876543210+    type family (+) (a :: Nat) (a :: Nat) :: Nat where+      (+) 'Zero m = m+      (+) ('Succ n) m = Apply SuccSym0 (Apply (Apply (+@#@$) n) m)+    type family Child (a :: Foo) :: Foo where+      Child FLeaf = FLeafSym0+      Child ((:+:) a _) = a+    (%+) ::+      forall (t :: Nat) (t :: Nat).+      Sing t -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat)+    sChild ::+      forall (t :: Foo). Sing t -> Sing (Apply ChildSym0 t :: Foo)+    (%+) SZero (sM :: Sing m) = sM+    (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)+      = (applySing ((singFun1 @SuccSym0) SSucc))+          ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sN)) sM)+    sChild SFLeaf = SFLeaf+    sChild ((:%+:) (sA :: Sing a) _) = sA+    instance SingI ((+@#@$) :: (~>) Nat ((~>) Nat Nat)) where+      sing = (singFun2 @(+@#@$)) (%+)+    instance SingI d =>+             SingI ((+@#@$$) (d :: Nat) :: (~>) Nat Nat) where+      sing = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) (sing @d))+    instance SingI (ChildSym0 :: (~>) Foo Foo) where+      sing = (singFun1 @ChildSym0) sChild+    data SFoo :: Foo -> GHC.Types.Type+      where+        SFLeaf :: SFoo FLeaf+        (:%+:) :: forall (n :: Foo) (n :: Foo).+                  (Sing (n :: Foo)) -> (Sing (n :: Foo)) -> SFoo ((:+:) n n)+    type instance Sing @Foo = SFoo+    instance SingKind Foo where+      type Demote Foo = Foo+      fromSing SFLeaf = FLeaf+      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) }+    instance SingI FLeaf where+      sing = SFLeaf+    instance (SingI n, SingI n) =>+             SingI ((:+:) (n :: Foo) (n :: Foo)) where+      sing = ((:%+:) sing) sing+    instance SingI ((:+:@#@$) :: (~>) Foo ((~>) Foo Foo)) where+      sing = (singFun2 @(:+:@#@$)) (:%+:)+    instance SingI d =>+             SingI ((:+:@#@$$) (d :: Foo) :: (~>) Foo Foo) where+      sing = (singFun1 @((:+:@#@$$) (d :: Foo))) ((:%+:) (sing @d))
− tests/compile-and-dump/Singletons/OrdDeriving.ghc86.template 
@@ -1,1235 +0,0 @@-Singletons/OrdDeriving.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Nat-            = Zero | Succ Nat-            deriving (Eq, Ord)-          data Foo a b c d-            = A a b c d |-              B a b c d |-              C a b c d |-              D a b c d |-              E a b c d |-              F a b c d-            deriving (Eq, Ord) |]-  ======>-    data Nat-      = Zero | Succ Nat-      deriving (Eq, Ord)-    data Foo a b c d-      = A a b c d |-        B a b c d |-        C a b c d |-        D a b c d |-        E a b c d |-        F a b c d-      deriving (Eq, Ord)-    type ZeroSym0 = Zero-    type SuccSym1 (t0123456789876543210 :: Nat) =-        Succ t0123456789876543210-    instance SuppressUnusedWarnings SuccSym0 where-      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())-    data SuccSym0 :: (~>) Nat Nat-      where-        SuccSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>-                                 SuccSym0 t0123456789876543210-    type instance Apply SuccSym0 t0123456789876543210 = Succ t0123456789876543210-    type ASym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =-        A t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ASym3KindInference) ())-    data ASym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.-                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)-      where-        ASym3KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (ASym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                              ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = A t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (ASym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ASym2KindInference) ())-    data ASym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210-                                                                                                                       d0123456789876543210.-                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))-      where-        ASym2KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (ASym2 t0123456789876543210 t0123456789876543210) arg) (ASym3 t0123456789876543210 t0123456789876543210 arg) =>-                              ASym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (ASym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (ASym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ASym1KindInference) ())-    data ASym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210-                                                                        c0123456789876543210-                                                                        d0123456789876543210.-                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))-      where-        ASym1KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (ASym1 t0123456789876543210) arg) (ASym2 t0123456789876543210 arg) =>-                              ASym1 t0123456789876543210 t0123456789876543210-    type instance Apply (ASym1 t0123456789876543210) t0123456789876543210 = ASym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ASym0 where-      suppressUnusedWarnings = snd (((,) ASym0KindInference) ())-    data ASym0 :: forall a0123456789876543210-                         b0123456789876543210-                         c0123456789876543210-                         d0123456789876543210.-                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))-      where-        ASym0KindInference :: forall t0123456789876543210-                                     arg. SameKind (Apply ASym0 arg) (ASym1 arg) =>-                              ASym0 t0123456789876543210-    type instance Apply ASym0 t0123456789876543210 = ASym1 t0123456789876543210-    type BSym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =-        B t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BSym3KindInference) ())-    data BSym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.-                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)-      where-        BSym3KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (BSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                              BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = B t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BSym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BSym2KindInference) ())-    data BSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210-                                                                                                                       d0123456789876543210.-                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))-      where-        BSym2KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (BSym2 t0123456789876543210 t0123456789876543210) arg) (BSym3 t0123456789876543210 t0123456789876543210 arg) =>-                              BSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (BSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BSym1KindInference) ())-    data BSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210-                                                                        c0123456789876543210-                                                                        d0123456789876543210.-                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))-      where-        BSym1KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (BSym1 t0123456789876543210) arg) (BSym2 t0123456789876543210 arg) =>-                              BSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (BSym1 t0123456789876543210) t0123456789876543210 = BSym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings BSym0 where-      suppressUnusedWarnings = snd (((,) BSym0KindInference) ())-    data BSym0 :: forall a0123456789876543210-                         b0123456789876543210-                         c0123456789876543210-                         d0123456789876543210.-                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))-      where-        BSym0KindInference :: forall t0123456789876543210-                                     arg. SameKind (Apply BSym0 arg) (BSym1 arg) =>-                              BSym0 t0123456789876543210-    type instance Apply BSym0 t0123456789876543210 = BSym1 t0123456789876543210-    type CSym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =-        C t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) CSym3KindInference) ())-    data CSym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.-                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)-      where-        CSym3KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (CSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                              CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = C t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (CSym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) CSym2KindInference) ())-    data CSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210-                                                                                                                       d0123456789876543210.-                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))-      where-        CSym2KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (CSym2 t0123456789876543210 t0123456789876543210) arg) (CSym3 t0123456789876543210 t0123456789876543210 arg) =>-                              CSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (CSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (CSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) CSym1KindInference) ())-    data CSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210-                                                                        c0123456789876543210-                                                                        d0123456789876543210.-                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))-      where-        CSym1KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (CSym1 t0123456789876543210) arg) (CSym2 t0123456789876543210 arg) =>-                              CSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (CSym1 t0123456789876543210) t0123456789876543210 = CSym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings CSym0 where-      suppressUnusedWarnings = snd (((,) CSym0KindInference) ())-    data CSym0 :: forall a0123456789876543210-                         b0123456789876543210-                         c0123456789876543210-                         d0123456789876543210.-                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))-      where-        CSym0KindInference :: forall t0123456789876543210-                                     arg. SameKind (Apply CSym0 arg) (CSym1 arg) =>-                              CSym0 t0123456789876543210-    type instance Apply CSym0 t0123456789876543210 = CSym1 t0123456789876543210-    type DSym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =-        D t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) DSym3KindInference) ())-    data DSym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.-                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)-      where-        DSym3KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (DSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                              DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = D t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (DSym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) DSym2KindInference) ())-    data DSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210-                                                                                                                       d0123456789876543210.-                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))-      where-        DSym2KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (DSym2 t0123456789876543210 t0123456789876543210) arg) (DSym3 t0123456789876543210 t0123456789876543210 arg) =>-                              DSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (DSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (DSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) DSym1KindInference) ())-    data DSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210-                                                                        c0123456789876543210-                                                                        d0123456789876543210.-                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))-      where-        DSym1KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (DSym1 t0123456789876543210) arg) (DSym2 t0123456789876543210 arg) =>-                              DSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (DSym1 t0123456789876543210) t0123456789876543210 = DSym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings DSym0 where-      suppressUnusedWarnings = snd (((,) DSym0KindInference) ())-    data DSym0 :: forall a0123456789876543210-                         b0123456789876543210-                         c0123456789876543210-                         d0123456789876543210.-                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))-      where-        DSym0KindInference :: forall t0123456789876543210-                                     arg. SameKind (Apply DSym0 arg) (DSym1 arg) =>-                              DSym0 t0123456789876543210-    type instance Apply DSym0 t0123456789876543210 = DSym1 t0123456789876543210-    type ESym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =-        E t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ESym3KindInference) ())-    data ESym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.-                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)-      where-        ESym3KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (ESym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                              ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = E t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (ESym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ESym2KindInference) ())-    data ESym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210-                                                                                                                       d0123456789876543210.-                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))-      where-        ESym2KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (ESym2 t0123456789876543210 t0123456789876543210) arg) (ESym3 t0123456789876543210 t0123456789876543210 arg) =>-                              ESym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (ESym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (ESym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ESym1KindInference) ())-    data ESym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210-                                                                        c0123456789876543210-                                                                        d0123456789876543210.-                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))-      where-        ESym1KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (ESym1 t0123456789876543210) arg) (ESym2 t0123456789876543210 arg) =>-                              ESym1 t0123456789876543210 t0123456789876543210-    type instance Apply (ESym1 t0123456789876543210) t0123456789876543210 = ESym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ESym0 where-      suppressUnusedWarnings = snd (((,) ESym0KindInference) ())-    data ESym0 :: forall a0123456789876543210-                         b0123456789876543210-                         c0123456789876543210-                         d0123456789876543210.-                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))-      where-        ESym0KindInference :: forall t0123456789876543210-                                     arg. SameKind (Apply ESym0 arg) (ESym1 arg) =>-                              ESym0 t0123456789876543210-    type instance Apply ESym0 t0123456789876543210 = ESym1 t0123456789876543210-    type FSym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =-        F t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FSym3KindInference) ())-    data FSym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.-                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)-      where-        FSym3KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (FSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>-                              FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = F t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (FSym2 t0123456789876543210 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FSym2KindInference) ())-    data FSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210-                                                                                                                       d0123456789876543210.-                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))-      where-        FSym2KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (FSym2 t0123456789876543210 t0123456789876543210) arg) (FSym3 t0123456789876543210 t0123456789876543210 arg) =>-                              FSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210-    type instance Apply (FSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (FSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FSym1KindInference) ())-    data FSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210-                                                                        c0123456789876543210-                                                                        d0123456789876543210.-                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))-      where-        FSym1KindInference :: forall t0123456789876543210-                                     t0123456789876543210-                                     arg. SameKind (Apply (FSym1 t0123456789876543210) arg) (FSym2 t0123456789876543210 arg) =>-                              FSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (FSym1 t0123456789876543210) t0123456789876543210 = FSym2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings FSym0 where-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())-    data FSym0 :: forall a0123456789876543210-                         b0123456789876543210-                         c0123456789876543210-                         d0123456789876543210.-                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))-      where-        FSym0KindInference :: forall t0123456789876543210-                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>-                              FSym0 t0123456789876543210-    type instance Apply FSym0 t0123456789876543210 = FSym1 t0123456789876543210-    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where-      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])-      Compare_0123456789876543210 Zero (Succ _) = LTSym0-      Compare_0123456789876543210 (Succ _) Zero = GTSym0-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd Nat where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Compare_0123456789876543210 (a :: Foo a b c d) (a :: Foo a b c d) :: Ordering where-      Compare_0123456789876543210 (A a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (A b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))-      Compare_0123456789876543210 (B a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (B b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))-      Compare_0123456789876543210 (C a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (C b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))-      Compare_0123456789876543210 (D a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (D b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))-      Compare_0123456789876543210 (E a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (E b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))-      Compare_0123456789876543210 (F a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (F b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))-      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_0123456789876543210Sym2 (a0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) (a0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) :: (~>) (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: forall a0123456789876543210-                                                   b0123456789876543210-                                                   c0123456789876543210-                                                   d0123456789876543210.-                                            (~>) (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) ((~>) (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd (Foo a b c d) where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Equals_0123456789876543210 (a :: Nat) (b :: Nat) :: Bool where-      Equals_0123456789876543210 Zero Zero = TrueSym0-      Equals_0123456789876543210 (Succ a) (Succ b) = (==) a b-      Equals_0123456789876543210 (_ :: Nat) (_ :: Nat) = FalseSym0-    instance PEq Nat where-      type (==) a b = Equals_0123456789876543210 a b-    type family Equals_0123456789876543210 (a :: Foo a b c d) (b :: Foo a b c d) :: Bool where-      Equals_0123456789876543210 (A a a a a) (A b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))-      Equals_0123456789876543210 (B a a a a) (B b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))-      Equals_0123456789876543210 (C a a a a) (C b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))-      Equals_0123456789876543210 (D a a a a) (D b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))-      Equals_0123456789876543210 (E a a a a) (E b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))-      Equals_0123456789876543210 (F a a a a) (F b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))-      Equals_0123456789876543210 (_ :: Foo a b c d) (_ :: Foo a b c d) = FalseSym0-    instance PEq (Foo a b c d) where-      type (==) a b = Equals_0123456789876543210 a b-    data instance Sing :: Nat -> GHC.Types.Type-      where-        SZero :: Sing Zero-        SSucc :: forall (n :: Nat). (Sing (n :: Nat)) -> Sing (Succ n)-    type SNat = (Sing :: Nat -> GHC.Types.Type)-    instance SingKind Nat where-      type Demote Nat = Nat-      fromSing SZero = Zero-      fromSing (SSucc b) = Succ (fromSing b)-      toSing Zero = SomeSing SZero-      toSing (Succ (b :: Demote Nat))-        = case toSing b :: SomeSing Nat of {-            SomeSing c -> SomeSing (SSucc c) }-    data instance Sing :: Foo a b c d -> GHC.Types.Type-      where-        SA :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).-              (Sing (n :: a))-              -> (Sing (n :: b))-                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> Sing (A n n n n)-        SB :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).-              (Sing (n :: a))-              -> (Sing (n :: b))-                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> Sing (B n n n n)-        SC :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).-              (Sing (n :: a))-              -> (Sing (n :: b))-                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> Sing (C n n n n)-        SD :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).-              (Sing (n :: a))-              -> (Sing (n :: b))-                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> Sing (D n n n n)-        SE :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).-              (Sing (n :: a))-              -> (Sing (n :: b))-                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> Sing (E n n n n)-        SF :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).-              (Sing (n :: a))-              -> (Sing (n :: b))-                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> Sing (F n n n n)-    type SFoo = (Sing :: Foo a b c d -> GHC.Types.Type)-    instance (SingKind a, SingKind b, SingKind c, SingKind d) =>-             SingKind (Foo a b c d) where-      type Demote (Foo a b c d) = Foo (Demote a) (Demote b) (Demote c) (Demote d)-      fromSing (SA b b b b)-        = (((A (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)-      fromSing (SB b b b b)-        = (((B (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)-      fromSing (SC b b b b)-        = (((C (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)-      fromSing (SD b b b b)-        = (((D (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)-      fromSing (SE b b b b)-        = (((E (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)-      fromSing (SF b b b b)-        = (((F (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)-      toSing-        (A (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))-        = case-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))-                 (toSing b :: SomeSing c))-                (toSing b :: SomeSing d)-          of {-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)-              -> SomeSing ((((SA c) c) c) c) }-      toSing-        (B (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))-        = case-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))-                 (toSing b :: SomeSing c))-                (toSing b :: SomeSing d)-          of {-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)-              -> SomeSing ((((SB c) c) c) c) }-      toSing-        (C (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))-        = case-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))-                 (toSing b :: SomeSing c))-                (toSing b :: SomeSing d)-          of {-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)-              -> SomeSing ((((SC c) c) c) c) }-      toSing-        (D (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))-        = case-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))-                 (toSing b :: SomeSing c))-                (toSing b :: SomeSing d)-          of {-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)-              -> SomeSing ((((SD c) c) c) c) }-      toSing-        (E (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))-        = case-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))-                 (toSing b :: SomeSing c))-                (toSing b :: SomeSing d)-          of {-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)-              -> SomeSing ((((SE c) c) c) c) }-      toSing-        (F (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))-        = case-              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))-                 (toSing b :: SomeSing c))-                (toSing b :: SomeSing d)-          of {-            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)-              -> SomeSing ((((SF c) c) c) c) }-    instance SOrd Nat => SOrd Nat where-      sCompare ::-        forall (t1 :: Nat) (t2 :: Nat).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)-                                                 -> GHC.Types.Type) t1) t2)-      sCompare SZero SZero-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            SNil-      sCompare-        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               SNil)-      sCompare SZero (SSucc _) = SLT-      sCompare (SSucc _) SZero = SGT-    instance (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)-                                                 -> GHC.Types.Type) t1) t2)-      sCompare-        (SA (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SA (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               ((applySing-                   ((applySing ((singFun2 @(:@#@$)) SCons))-                      ((applySing-                          ((applySing ((singFun2 @CompareSym0) sCompare))-                             sA_0123456789876543210))-                         sB_0123456789876543210)))-                  ((applySing-                      ((applySing ((singFun2 @(:@#@$)) SCons))-                         ((applySing-                             ((applySing ((singFun2 @CompareSym0) sCompare))-                                sA_0123456789876543210))-                            sB_0123456789876543210)))-                     ((applySing-                         ((applySing ((singFun2 @(:@#@$)) SCons))-                            ((applySing-                                ((applySing ((singFun2 @CompareSym0) sCompare))-                                   sA_0123456789876543210))-                               sB_0123456789876543210)))-                        SNil))))-      sCompare-        (SB (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SB (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               ((applySing-                   ((applySing ((singFun2 @(:@#@$)) SCons))-                      ((applySing-                          ((applySing ((singFun2 @CompareSym0) sCompare))-                             sA_0123456789876543210))-                         sB_0123456789876543210)))-                  ((applySing-                      ((applySing ((singFun2 @(:@#@$)) SCons))-                         ((applySing-                             ((applySing ((singFun2 @CompareSym0) sCompare))-                                sA_0123456789876543210))-                            sB_0123456789876543210)))-                     ((applySing-                         ((applySing ((singFun2 @(:@#@$)) SCons))-                            ((applySing-                                ((applySing ((singFun2 @CompareSym0) sCompare))-                                   sA_0123456789876543210))-                               sB_0123456789876543210)))-                        SNil))))-      sCompare-        (SC (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SC (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               ((applySing-                   ((applySing ((singFun2 @(:@#@$)) SCons))-                      ((applySing-                          ((applySing ((singFun2 @CompareSym0) sCompare))-                             sA_0123456789876543210))-                         sB_0123456789876543210)))-                  ((applySing-                      ((applySing ((singFun2 @(:@#@$)) SCons))-                         ((applySing-                             ((applySing ((singFun2 @CompareSym0) sCompare))-                                sA_0123456789876543210))-                            sB_0123456789876543210)))-                     ((applySing-                         ((applySing ((singFun2 @(:@#@$)) SCons))-                            ((applySing-                                ((applySing ((singFun2 @CompareSym0) sCompare))-                                   sA_0123456789876543210))-                               sB_0123456789876543210)))-                        SNil))))-      sCompare-        (SD (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SD (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               ((applySing-                   ((applySing ((singFun2 @(:@#@$)) SCons))-                      ((applySing-                          ((applySing ((singFun2 @CompareSym0) sCompare))-                             sA_0123456789876543210))-                         sB_0123456789876543210)))-                  ((applySing-                      ((applySing ((singFun2 @(:@#@$)) SCons))-                         ((applySing-                             ((applySing ((singFun2 @CompareSym0) sCompare))-                                sA_0123456789876543210))-                            sB_0123456789876543210)))-                     ((applySing-                         ((applySing ((singFun2 @(:@#@$)) SCons))-                            ((applySing-                                ((applySing ((singFun2 @CompareSym0) sCompare))-                                   sA_0123456789876543210))-                               sB_0123456789876543210)))-                        SNil))))-      sCompare-        (SE (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SE (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               ((applySing-                   ((applySing ((singFun2 @(:@#@$)) SCons))-                      ((applySing-                          ((applySing ((singFun2 @CompareSym0) sCompare))-                             sA_0123456789876543210))-                         sB_0123456789876543210)))-                  ((applySing-                      ((applySing ((singFun2 @(:@#@$)) SCons))-                         ((applySing-                             ((applySing ((singFun2 @CompareSym0) sCompare))-                                sA_0123456789876543210))-                            sB_0123456789876543210)))-                     ((applySing-                         ((applySing ((singFun2 @(:@#@$)) SCons))-                            ((applySing-                                ((applySing ((singFun2 @CompareSym0) sCompare))-                                   sA_0123456789876543210))-                               sB_0123456789876543210)))-                        SNil))))-      sCompare-        (SF (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210)-            (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SF (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210)-            (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               ((applySing-                   ((applySing ((singFun2 @(:@#@$)) SCons))-                      ((applySing-                          ((applySing ((singFun2 @CompareSym0) sCompare))-                             sA_0123456789876543210))-                         sB_0123456789876543210)))-                  ((applySing-                      ((applySing ((singFun2 @(:@#@$)) SCons))-                         ((applySing-                             ((applySing ((singFun2 @CompareSym0) sCompare))-                                sA_0123456789876543210))-                            sB_0123456789876543210)))-                     ((applySing-                         ((applySing ((singFun2 @(:@#@$)) SCons))-                            ((applySing-                                ((applySing ((singFun2 @CompareSym0) sCompare))-                                   sA_0123456789876543210))-                               sB_0123456789876543210)))-                        SNil))))-      sCompare (SA _ _ _ _) (SB _ _ _ _) = SLT-      sCompare (SA _ _ _ _) (SC _ _ _ _) = SLT-      sCompare (SA _ _ _ _) (SD _ _ _ _) = SLT-      sCompare (SA _ _ _ _) (SE _ _ _ _) = SLT-      sCompare (SA _ _ _ _) (SF _ _ _ _) = SLT-      sCompare (SB _ _ _ _) (SA _ _ _ _) = SGT-      sCompare (SB _ _ _ _) (SC _ _ _ _) = SLT-      sCompare (SB _ _ _ _) (SD _ _ _ _) = SLT-      sCompare (SB _ _ _ _) (SE _ _ _ _) = SLT-      sCompare (SB _ _ _ _) (SF _ _ _ _) = SLT-      sCompare (SC _ _ _ _) (SA _ _ _ _) = SGT-      sCompare (SC _ _ _ _) (SB _ _ _ _) = SGT-      sCompare (SC _ _ _ _) (SD _ _ _ _) = SLT-      sCompare (SC _ _ _ _) (SE _ _ _ _) = SLT-      sCompare (SC _ _ _ _) (SF _ _ _ _) = SLT-      sCompare (SD _ _ _ _) (SA _ _ _ _) = SGT-      sCompare (SD _ _ _ _) (SB _ _ _ _) = SGT-      sCompare (SD _ _ _ _) (SC _ _ _ _) = SGT-      sCompare (SD _ _ _ _) (SE _ _ _ _) = SLT-      sCompare (SD _ _ _ _) (SF _ _ _ _) = SLT-      sCompare (SE _ _ _ _) (SA _ _ _ _) = SGT-      sCompare (SE _ _ _ _) (SB _ _ _ _) = SGT-      sCompare (SE _ _ _ _) (SC _ _ _ _) = SGT-      sCompare (SE _ _ _ _) (SD _ _ _ _) = SGT-      sCompare (SE _ _ _ _) (SF _ _ _ _) = SLT-      sCompare (SF _ _ _ _) (SA _ _ _ _) = SGT-      sCompare (SF _ _ _ _) (SB _ _ _ _) = SGT-      sCompare (SF _ _ _ _) (SC _ _ _ _) = SGT-      sCompare (SF _ _ _ _) (SD _ _ _ _) = SGT-      sCompare (SF _ _ _ _) (SE _ _ _ _) = SGT-    instance SEq Nat => SEq Nat where-      (%==) SZero SZero = STrue-      (%==) SZero (SSucc _) = SFalse-      (%==) (SSucc _) SZero = SFalse-      (%==) (SSucc a) (SSucc b) = ((%==) a) b-    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 (SEq a, SEq b, SEq c, SEq d) => SEq (Foo a b c d) where-      (%==) (SA a a a a) (SA b b b b)-        = ((%&&) (((%==) a) b))-            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))-      (%==) (SA _ _ _ _) (SB _ _ _ _) = SFalse-      (%==) (SA _ _ _ _) (SC _ _ _ _) = SFalse-      (%==) (SA _ _ _ _) (SD _ _ _ _) = SFalse-      (%==) (SA _ _ _ _) (SE _ _ _ _) = SFalse-      (%==) (SA _ _ _ _) (SF _ _ _ _) = SFalse-      (%==) (SB _ _ _ _) (SA _ _ _ _) = SFalse-      (%==) (SB a a a a) (SB b b b b)-        = ((%&&) (((%==) a) b))-            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))-      (%==) (SB _ _ _ _) (SC _ _ _ _) = SFalse-      (%==) (SB _ _ _ _) (SD _ _ _ _) = SFalse-      (%==) (SB _ _ _ _) (SE _ _ _ _) = SFalse-      (%==) (SB _ _ _ _) (SF _ _ _ _) = SFalse-      (%==) (SC _ _ _ _) (SA _ _ _ _) = SFalse-      (%==) (SC _ _ _ _) (SB _ _ _ _) = SFalse-      (%==) (SC a a a a) (SC b b b b)-        = ((%&&) (((%==) a) b))-            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))-      (%==) (SC _ _ _ _) (SD _ _ _ _) = SFalse-      (%==) (SC _ _ _ _) (SE _ _ _ _) = SFalse-      (%==) (SC _ _ _ _) (SF _ _ _ _) = SFalse-      (%==) (SD _ _ _ _) (SA _ _ _ _) = SFalse-      (%==) (SD _ _ _ _) (SB _ _ _ _) = SFalse-      (%==) (SD _ _ _ _) (SC _ _ _ _) = SFalse-      (%==) (SD a a a a) (SD b b b b)-        = ((%&&) (((%==) a) b))-            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))-      (%==) (SD _ _ _ _) (SE _ _ _ _) = SFalse-      (%==) (SD _ _ _ _) (SF _ _ _ _) = SFalse-      (%==) (SE _ _ _ _) (SA _ _ _ _) = SFalse-      (%==) (SE _ _ _ _) (SB _ _ _ _) = SFalse-      (%==) (SE _ _ _ _) (SC _ _ _ _) = SFalse-      (%==) (SE _ _ _ _) (SD _ _ _ _) = SFalse-      (%==) (SE a a a a) (SE b b b b)-        = ((%&&) (((%==) a) b))-            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))-      (%==) (SE _ _ _ _) (SF _ _ _ _) = SFalse-      (%==) (SF _ _ _ _) (SA _ _ _ _) = SFalse-      (%==) (SF _ _ _ _) (SB _ _ _ _) = SFalse-      (%==) (SF _ _ _ _) (SC _ _ _ _) = SFalse-      (%==) (SF _ _ _ _) (SD _ _ _ _) = SFalse-      (%==) (SF _ _ _ _) (SE _ _ _ _) = SFalse-      (%==) (SF a a a a) (SF b b b b)-        = ((%&&) (((%==) a) b))-            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))-    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>-             SDecide (Foo a b c d) where-      (%~) (SA a a a a) (SA b b b b)-        = case-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)-          of-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)-              -> Proved Refl-            (,,,) (Disproved contra) _ _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ (Disproved contra) _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ (Disproved contra) _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ _ (Disproved contra)-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-      (%~) (SA _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SA _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SA _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SA _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SA _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SB _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SB a a a a) (SB b b b b)-        = case-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)-          of-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)-              -> Proved Refl-            (,,,) (Disproved contra) _ _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ (Disproved contra) _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ (Disproved contra) _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ _ (Disproved contra)-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-      (%~) (SB _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SB _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SB _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SB _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SC _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SC _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SC a a a a) (SC b b b b)-        = case-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)-          of-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)-              -> Proved Refl-            (,,,) (Disproved contra) _ _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ (Disproved contra) _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ (Disproved contra) _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ _ (Disproved contra)-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-      (%~) (SC _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SC _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SC _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SD _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SD _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SD _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SD a a a a) (SD b b b b)-        = case-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)-          of-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)-              -> Proved Refl-            (,,,) (Disproved contra) _ _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ (Disproved contra) _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ (Disproved contra) _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ _ (Disproved contra)-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-      (%~) (SD _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SD _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SE _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SE _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SE _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SE _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SE a a a a) (SE b b b b)-        = case-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)-          of-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)-              -> Proved Refl-            (,,,) (Disproved contra) _ _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ (Disproved contra) _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ (Disproved contra) _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ _ (Disproved contra)-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-      (%~) (SE _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SF _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SF _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SF _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SF _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SF _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)-      (%~) (SF a a a a) (SF b b b b)-        = case-              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)-          of-            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)-              -> Proved Refl-            (,,,) (Disproved contra) _ _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ (Disproved contra) _ _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ (Disproved contra) _-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-            (,,,) _ _ _ (Disproved contra)-              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })-    instance SingI Zero where-      sing = SZero-    instance SingI n => SingI (Succ (n :: Nat)) where-      sing = SSucc sing-    instance SingI (SuccSym0 :: (~>) Nat Nat) where-      sing = (singFun1 @SuccSym0) SSucc-    instance SingI (TyCon1 Succ :: (~>) Nat Nat) where-      sing = (singFun1 @(TyCon1 Succ)) SSucc-    instance (SingI n, SingI n, SingI n, SingI n) =>-             SingI (A (n :: a) (n :: b) (n :: c) (n :: d)) where-      sing = (((SA sing) sing) sing) sing-    instance SingI (ASym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @ASym0) SA-    instance SingI (TyCon4 A :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @(TyCon4 A)) SA-    instance SingI d =>-             SingI (ASym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(ASym1 (d :: a))) (SA (sing @d))-    instance SingI d =>-             SingI (TyCon3 (A (d :: a)) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(TyCon3 (A (d :: a)))) (SA (sing @d))-    instance (SingI d, SingI d) =>-             SingI (ASym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(ASym2 (d :: a) (d :: b))) ((SA (sing @d)) (sing @d))-    instance (SingI d, SingI d) =>-             SingI (TyCon2 (A (d :: a) (d :: b)) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(TyCon2 (A (d :: a) (d :: b))))-            ((SA (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (ASym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(ASym3 (d :: a) (d :: b) (d :: c)))-            (((SA (sing @d)) (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (TyCon1 (A (d :: a) (d :: b) (d :: c)) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(TyCon1 (A (d :: a) (d :: b) (d :: c))))-            (((SA (sing @d)) (sing @d)) (sing @d))-    instance (SingI n, SingI n, SingI n, SingI n) =>-             SingI (B (n :: a) (n :: b) (n :: c) (n :: d)) where-      sing = (((SB sing) sing) sing) sing-    instance SingI (BSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @BSym0) SB-    instance SingI (TyCon4 B :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @(TyCon4 B)) SB-    instance SingI d =>-             SingI (BSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(BSym1 (d :: a))) (SB (sing @d))-    instance SingI d =>-             SingI (TyCon3 (B (d :: a)) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(TyCon3 (B (d :: a)))) (SB (sing @d))-    instance (SingI d, SingI d) =>-             SingI (BSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(BSym2 (d :: a) (d :: b))) ((SB (sing @d)) (sing @d))-    instance (SingI d, SingI d) =>-             SingI (TyCon2 (B (d :: a) (d :: b)) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(TyCon2 (B (d :: a) (d :: b))))-            ((SB (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (BSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(BSym3 (d :: a) (d :: b) (d :: c)))-            (((SB (sing @d)) (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (TyCon1 (B (d :: a) (d :: b) (d :: c)) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(TyCon1 (B (d :: a) (d :: b) (d :: c))))-            (((SB (sing @d)) (sing @d)) (sing @d))-    instance (SingI n, SingI n, SingI n, SingI n) =>-             SingI (C (n :: a) (n :: b) (n :: c) (n :: d)) where-      sing = (((SC sing) sing) sing) sing-    instance SingI (CSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @CSym0) SC-    instance SingI (TyCon4 C :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @(TyCon4 C)) SC-    instance SingI d =>-             SingI (CSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(CSym1 (d :: a))) (SC (sing @d))-    instance SingI d =>-             SingI (TyCon3 (C (d :: a)) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(TyCon3 (C (d :: a)))) (SC (sing @d))-    instance (SingI d, SingI d) =>-             SingI (CSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(CSym2 (d :: a) (d :: b))) ((SC (sing @d)) (sing @d))-    instance (SingI d, SingI d) =>-             SingI (TyCon2 (C (d :: a) (d :: b)) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(TyCon2 (C (d :: a) (d :: b))))-            ((SC (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (CSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(CSym3 (d :: a) (d :: b) (d :: c)))-            (((SC (sing @d)) (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (TyCon1 (C (d :: a) (d :: b) (d :: c)) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(TyCon1 (C (d :: a) (d :: b) (d :: c))))-            (((SC (sing @d)) (sing @d)) (sing @d))-    instance (SingI n, SingI n, SingI n, SingI n) =>-             SingI (D (n :: a) (n :: b) (n :: c) (n :: d)) where-      sing = (((SD sing) sing) sing) sing-    instance SingI (DSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @DSym0) SD-    instance SingI (TyCon4 D :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @(TyCon4 D)) SD-    instance SingI d =>-             SingI (DSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(DSym1 (d :: a))) (SD (sing @d))-    instance SingI d =>-             SingI (TyCon3 (D (d :: a)) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(TyCon3 (D (d :: a)))) (SD (sing @d))-    instance (SingI d, SingI d) =>-             SingI (DSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(DSym2 (d :: a) (d :: b))) ((SD (sing @d)) (sing @d))-    instance (SingI d, SingI d) =>-             SingI (TyCon2 (D (d :: a) (d :: b)) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(TyCon2 (D (d :: a) (d :: b))))-            ((SD (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (DSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(DSym3 (d :: a) (d :: b) (d :: c)))-            (((SD (sing @d)) (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (TyCon1 (D (d :: a) (d :: b) (d :: c)) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(TyCon1 (D (d :: a) (d :: b) (d :: c))))-            (((SD (sing @d)) (sing @d)) (sing @d))-    instance (SingI n, SingI n, SingI n, SingI n) =>-             SingI (E (n :: a) (n :: b) (n :: c) (n :: d)) where-      sing = (((SE sing) sing) sing) sing-    instance SingI (ESym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @ESym0) SE-    instance SingI (TyCon4 E :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @(TyCon4 E)) SE-    instance SingI d =>-             SingI (ESym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(ESym1 (d :: a))) (SE (sing @d))-    instance SingI d =>-             SingI (TyCon3 (E (d :: a)) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(TyCon3 (E (d :: a)))) (SE (sing @d))-    instance (SingI d, SingI d) =>-             SingI (ESym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(ESym2 (d :: a) (d :: b))) ((SE (sing @d)) (sing @d))-    instance (SingI d, SingI d) =>-             SingI (TyCon2 (E (d :: a) (d :: b)) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(TyCon2 (E (d :: a) (d :: b))))-            ((SE (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (ESym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(ESym3 (d :: a) (d :: b) (d :: c)))-            (((SE (sing @d)) (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (TyCon1 (E (d :: a) (d :: b) (d :: c)) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(TyCon1 (E (d :: a) (d :: b) (d :: c))))-            (((SE (sing @d)) (sing @d)) (sing @d))-    instance (SingI n, SingI n, SingI n, SingI n) =>-             SingI (F (n :: a) (n :: b) (n :: c) (n :: d)) where-      sing = (((SF sing) sing) sing) sing-    instance SingI (FSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @FSym0) SF-    instance SingI (TyCon4 F :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where-      sing = (singFun4 @(TyCon4 F)) SF-    instance SingI d =>-             SingI (FSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(FSym1 (d :: a))) (SF (sing @d))-    instance SingI d =>-             SingI (TyCon3 (F (d :: a)) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where-      sing = (singFun3 @(TyCon3 (F (d :: a)))) (SF (sing @d))-    instance (SingI d, SingI d) =>-             SingI (FSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(FSym2 (d :: a) (d :: b))) ((SF (sing @d)) (sing @d))-    instance (SingI d, SingI d) =>-             SingI (TyCon2 (F (d :: a) (d :: b)) :: (~>) c ((~>) d (Foo a b c d))) where-      sing-        = (singFun2 @(TyCon2 (F (d :: a) (d :: b))))-            ((SF (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (FSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(FSym3 (d :: a) (d :: b) (d :: c)))-            (((SF (sing @d)) (sing @d)) (sing @d))-    instance (SingI d, SingI d, SingI d) =>-             SingI (TyCon1 (F (d :: a) (d :: b) (d :: c)) :: (~>) d (Foo a b c d)) where-      sing-        = (singFun1 @(TyCon1 (F (d :: a) (d :: b) (d :: c))))-            (((SF (sing @d)) (sing @d)) (sing @d))
+ tests/compile-and-dump/Singletons/OrdDeriving.ghc88.template view
@@ -0,0 +1,1163 @@+Singletons/OrdDeriving.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Nat+            = Zero | Succ Nat+            deriving (Eq, Ord)+          data Foo a b c d+            = A a b c d |+              B a b c d |+              C a b c d |+              D a b c d |+              E a b c d |+              F a b c d+            deriving (Eq, Ord) |]+  ======>+    data Nat+      = Zero | Succ Nat+      deriving (Eq, Ord)+    data Foo a b c d+      = A a b c d |+        B a b c d |+        C a b c d |+        D a b c d |+        E a b c d |+        F a b c d+      deriving (Eq, Ord)+    type ZeroSym0 = Zero+    type SuccSym1 (t0123456789876543210 :: Nat) =+        Succ t0123456789876543210+    instance SuppressUnusedWarnings SuccSym0 where+      suppressUnusedWarnings = snd (((,) SuccSym0KindInference) ())+    data SuccSym0 :: (~>) Nat Nat+      where+        SuccSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply SuccSym0 arg) (SuccSym1 arg) =>+                                 SuccSym0 t0123456789876543210+    type instance Apply SuccSym0 t0123456789876543210 = Succ t0123456789876543210+    type ASym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =+        A t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ASym3KindInference) ())+    data ASym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.+                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)+      where+        ASym3KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (ASym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                              ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = A t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (ASym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ASym2KindInference) ())+    data ASym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210+                                                                                                                       d0123456789876543210.+                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))+      where+        ASym2KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (ASym2 t0123456789876543210 t0123456789876543210) arg) (ASym3 t0123456789876543210 t0123456789876543210 arg) =>+                              ASym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (ASym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = ASym3 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (ASym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ASym1KindInference) ())+    data ASym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210+                                                                        c0123456789876543210+                                                                        d0123456789876543210.+                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))+      where+        ASym1KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (ASym1 t0123456789876543210) arg) (ASym2 t0123456789876543210 arg) =>+                              ASym1 t0123456789876543210 t0123456789876543210+    type instance Apply (ASym1 t0123456789876543210) t0123456789876543210 = ASym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ASym0 where+      suppressUnusedWarnings = snd (((,) ASym0KindInference) ())+    data ASym0 :: forall a0123456789876543210+                         b0123456789876543210+                         c0123456789876543210+                         d0123456789876543210.+                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))+      where+        ASym0KindInference :: forall t0123456789876543210+                                     arg. SameKind (Apply ASym0 arg) (ASym1 arg) =>+                              ASym0 t0123456789876543210+    type instance Apply ASym0 t0123456789876543210 = ASym1 t0123456789876543210+    type BSym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =+        B t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BSym3KindInference) ())+    data BSym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.+                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)+      where+        BSym3KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (BSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                              BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = B t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BSym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BSym2KindInference) ())+    data BSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210+                                                                                                                       d0123456789876543210.+                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))+      where+        BSym2KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (BSym2 t0123456789876543210 t0123456789876543210) arg) (BSym3 t0123456789876543210 t0123456789876543210 arg) =>+                              BSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (BSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = BSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BSym1KindInference) ())+    data BSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210+                                                                        c0123456789876543210+                                                                        d0123456789876543210.+                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))+      where+        BSym1KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (BSym1 t0123456789876543210) arg) (BSym2 t0123456789876543210 arg) =>+                              BSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (BSym1 t0123456789876543210) t0123456789876543210 = BSym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings BSym0 where+      suppressUnusedWarnings = snd (((,) BSym0KindInference) ())+    data BSym0 :: forall a0123456789876543210+                         b0123456789876543210+                         c0123456789876543210+                         d0123456789876543210.+                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))+      where+        BSym0KindInference :: forall t0123456789876543210+                                     arg. SameKind (Apply BSym0 arg) (BSym1 arg) =>+                              BSym0 t0123456789876543210+    type instance Apply BSym0 t0123456789876543210 = BSym1 t0123456789876543210+    type CSym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =+        C t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) CSym3KindInference) ())+    data CSym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.+                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)+      where+        CSym3KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (CSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                              CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = C t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (CSym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) CSym2KindInference) ())+    data CSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210+                                                                                                                       d0123456789876543210.+                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))+      where+        CSym2KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (CSym2 t0123456789876543210 t0123456789876543210) arg) (CSym3 t0123456789876543210 t0123456789876543210 arg) =>+                              CSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (CSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = CSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (CSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) CSym1KindInference) ())+    data CSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210+                                                                        c0123456789876543210+                                                                        d0123456789876543210.+                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))+      where+        CSym1KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (CSym1 t0123456789876543210) arg) (CSym2 t0123456789876543210 arg) =>+                              CSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (CSym1 t0123456789876543210) t0123456789876543210 = CSym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings CSym0 where+      suppressUnusedWarnings = snd (((,) CSym0KindInference) ())+    data CSym0 :: forall a0123456789876543210+                         b0123456789876543210+                         c0123456789876543210+                         d0123456789876543210.+                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))+      where+        CSym0KindInference :: forall t0123456789876543210+                                     arg. SameKind (Apply CSym0 arg) (CSym1 arg) =>+                              CSym0 t0123456789876543210+    type instance Apply CSym0 t0123456789876543210 = CSym1 t0123456789876543210+    type DSym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =+        D t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) DSym3KindInference) ())+    data DSym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.+                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)+      where+        DSym3KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (DSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                              DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = D t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (DSym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) DSym2KindInference) ())+    data DSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210+                                                                                                                       d0123456789876543210.+                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))+      where+        DSym2KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (DSym2 t0123456789876543210 t0123456789876543210) arg) (DSym3 t0123456789876543210 t0123456789876543210 arg) =>+                              DSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (DSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = DSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (DSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) DSym1KindInference) ())+    data DSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210+                                                                        c0123456789876543210+                                                                        d0123456789876543210.+                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))+      where+        DSym1KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (DSym1 t0123456789876543210) arg) (DSym2 t0123456789876543210 arg) =>+                              DSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (DSym1 t0123456789876543210) t0123456789876543210 = DSym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings DSym0 where+      suppressUnusedWarnings = snd (((,) DSym0KindInference) ())+    data DSym0 :: forall a0123456789876543210+                         b0123456789876543210+                         c0123456789876543210+                         d0123456789876543210.+                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))+      where+        DSym0KindInference :: forall t0123456789876543210+                                     arg. SameKind (Apply DSym0 arg) (DSym1 arg) =>+                              DSym0 t0123456789876543210+    type instance Apply DSym0 t0123456789876543210 = DSym1 t0123456789876543210+    type ESym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =+        E t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ESym3KindInference) ())+    data ESym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.+                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)+      where+        ESym3KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (ESym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                              ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = E t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (ESym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ESym2KindInference) ())+    data ESym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210+                                                                                                                       d0123456789876543210.+                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))+      where+        ESym2KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (ESym2 t0123456789876543210 t0123456789876543210) arg) (ESym3 t0123456789876543210 t0123456789876543210 arg) =>+                              ESym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (ESym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = ESym3 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (ESym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ESym1KindInference) ())+    data ESym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210+                                                                        c0123456789876543210+                                                                        d0123456789876543210.+                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))+      where+        ESym1KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (ESym1 t0123456789876543210) arg) (ESym2 t0123456789876543210 arg) =>+                              ESym1 t0123456789876543210 t0123456789876543210+    type instance Apply (ESym1 t0123456789876543210) t0123456789876543210 = ESym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ESym0 where+      suppressUnusedWarnings = snd (((,) ESym0KindInference) ())+    data ESym0 :: forall a0123456789876543210+                         b0123456789876543210+                         c0123456789876543210+                         d0123456789876543210.+                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))+      where+        ESym0KindInference :: forall t0123456789876543210+                                     arg. SameKind (Apply ESym0 arg) (ESym1 arg) =>+                              ESym0 t0123456789876543210+    type instance Apply ESym0 t0123456789876543210 = ESym1 t0123456789876543210+    type FSym4 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) (t0123456789876543210 :: d0123456789876543210) =+        F t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FSym3KindInference) ())+    data FSym3 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) (t0123456789876543210 :: c0123456789876543210) :: forall d0123456789876543210.+                                                                                                                                                               (~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)+      where+        FSym3KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) arg) (FSym4 t0123456789876543210 t0123456789876543210 t0123456789876543210 arg) =>+                              FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210) t0123456789876543210 = F t0123456789876543210 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (FSym2 t0123456789876543210 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FSym2KindInference) ())+    data FSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) :: forall c0123456789876543210+                                                                                                                       d0123456789876543210.+                                                                                                                (~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))+      where+        FSym2KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (FSym2 t0123456789876543210 t0123456789876543210) arg) (FSym3 t0123456789876543210 t0123456789876543210 arg) =>+                              FSym2 t0123456789876543210 t0123456789876543210 t0123456789876543210+    type instance Apply (FSym2 t0123456789876543210 t0123456789876543210) t0123456789876543210 = FSym3 t0123456789876543210 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (FSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FSym1KindInference) ())+    data FSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210+                                                                        c0123456789876543210+                                                                        d0123456789876543210.+                                                                 (~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210)))+      where+        FSym1KindInference :: forall t0123456789876543210+                                     t0123456789876543210+                                     arg. SameKind (Apply (FSym1 t0123456789876543210) arg) (FSym2 t0123456789876543210 arg) =>+                              FSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (FSym1 t0123456789876543210) t0123456789876543210 = FSym2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings FSym0 where+      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())+    data FSym0 :: forall a0123456789876543210+                         b0123456789876543210+                         c0123456789876543210+                         d0123456789876543210.+                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) c0123456789876543210 ((~>) d0123456789876543210 (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210))))+      where+        FSym0KindInference :: forall t0123456789876543210+                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>+                              FSym0 t0123456789876543210+    type instance Apply FSym0 t0123456789876543210 = FSym1 t0123456789876543210+    type family Compare_0123456789876543210 (a :: Nat) (a :: Nat) :: Ordering where+      Compare_0123456789876543210 Zero Zero = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 (Succ a_0123456789876543210) (Succ b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])+      Compare_0123456789876543210 Zero (Succ _) = LTSym0+      Compare_0123456789876543210 (Succ _) Zero = GTSym0+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Nat Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) Nat ((~>) Nat Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd Nat where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family Compare_0123456789876543210 (a :: Foo a b c d) (a :: Foo a b c d) :: Ordering where+      Compare_0123456789876543210 (A a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (A b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))+      Compare_0123456789876543210 (B a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (B b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))+      Compare_0123456789876543210 (C a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (C b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))+      Compare_0123456789876543210 (D a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (D b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))+      Compare_0123456789876543210 (E a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (E b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))+      Compare_0123456789876543210 (F a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) (F b_0123456789876543210 b_0123456789876543210 b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))))+      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_0123456789876543210Sym2 (a0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) (a0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) :: (~>) (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: forall a0123456789876543210+                                                   b0123456789876543210+                                                   c0123456789876543210+                                                   d0123456789876543210.+                                            (~>) (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) ((~>) (Foo a0123456789876543210 b0123456789876543210 c0123456789876543210 d0123456789876543210) Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd (Foo a b c d) where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family Equals_0123456789876543210 (a :: Nat) (b :: Nat) :: Bool where+      Equals_0123456789876543210 Zero Zero = TrueSym0+      Equals_0123456789876543210 (Succ a) (Succ b) = (==) a b+      Equals_0123456789876543210 (_ :: Nat) (_ :: Nat) = FalseSym0+    instance PEq Nat where+      type (==) a b = Equals_0123456789876543210 a b+    type family Equals_0123456789876543210 (a :: Foo a b c d) (b :: Foo a b c d) :: Bool where+      Equals_0123456789876543210 (A a a a a) (A b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))+      Equals_0123456789876543210 (B a a a a) (B b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))+      Equals_0123456789876543210 (C a a a a) (C b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))+      Equals_0123456789876543210 (D a a a a) (D b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))+      Equals_0123456789876543210 (E a a a a) (E b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))+      Equals_0123456789876543210 (F a a a a) (F b b b b) = (&&) ((==) a b) ((&&) ((==) a b) ((&&) ((==) a b) ((==) a b)))+      Equals_0123456789876543210 (_ :: Foo a b c d) (_ :: Foo a b c d) = FalseSym0+    instance PEq (Foo a b c d) where+      type (==) a b = Equals_0123456789876543210 a b+    data SNat :: Nat -> GHC.Types.Type+      where+        SZero :: SNat Zero+        SSucc :: forall (n :: Nat). (Sing (n :: Nat)) -> SNat (Succ n)+    type instance Sing @Nat = SNat+    instance SingKind Nat where+      type Demote Nat = Nat+      fromSing SZero = Zero+      fromSing (SSucc b) = Succ (fromSing b)+      toSing Zero = SomeSing SZero+      toSing (Succ (b :: Demote Nat))+        = case toSing b :: SomeSing Nat of {+            SomeSing c -> SomeSing (SSucc c) }+    data SFoo :: forall a b c d. Foo a b c d -> GHC.Types.Type+      where+        SA :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).+              (Sing (n :: a))+              -> (Sing (n :: b))+                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> SFoo (A n n n n)+        SB :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).+              (Sing (n :: a))+              -> (Sing (n :: b))+                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> SFoo (B n n n n)+        SC :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).+              (Sing (n :: a))+              -> (Sing (n :: b))+                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> SFoo (C n n n n)+        SD :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).+              (Sing (n :: a))+              -> (Sing (n :: b))+                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> SFoo (D n n n n)+        SE :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).+              (Sing (n :: a))+              -> (Sing (n :: b))+                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> SFoo (E n n n n)+        SF :: forall a b c d (n :: a) (n :: b) (n :: c) (n :: d).+              (Sing (n :: a))+              -> (Sing (n :: b))+                 -> (Sing (n :: c)) -> (Sing (n :: d)) -> SFoo (F n n n n)+    type instance Sing @(Foo a b c d) = SFoo+    instance (SingKind a, SingKind b, SingKind c, SingKind d) =>+             SingKind (Foo a b c d) where+      type Demote (Foo a b c d) = Foo (Demote a) (Demote b) (Demote c) (Demote d)+      fromSing (SA b b b b)+        = (((A (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)+      fromSing (SB b b b b)+        = (((B (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)+      fromSing (SC b b b b)+        = (((C (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)+      fromSing (SD b b b b)+        = (((D (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)+      fromSing (SE b b b b)+        = (((E (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)+      fromSing (SF b b b b)+        = (((F (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)+      toSing+        (A (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))+        = case+              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))+                 (toSing b :: SomeSing c))+                (toSing b :: SomeSing d)+          of {+            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)+              -> SomeSing ((((SA c) c) c) c) }+      toSing+        (B (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))+        = case+              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))+                 (toSing b :: SomeSing c))+                (toSing b :: SomeSing d)+          of {+            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)+              -> SomeSing ((((SB c) c) c) c) }+      toSing+        (C (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))+        = case+              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))+                 (toSing b :: SomeSing c))+                (toSing b :: SomeSing d)+          of {+            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)+              -> SomeSing ((((SC c) c) c) c) }+      toSing+        (D (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))+        = case+              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))+                 (toSing b :: SomeSing c))+                (toSing b :: SomeSing d)+          of {+            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)+              -> SomeSing ((((SD c) c) c) c) }+      toSing+        (E (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))+        = case+              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))+                 (toSing b :: SomeSing c))+                (toSing b :: SomeSing d)+          of {+            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)+              -> SomeSing ((((SE c) c) c) c) }+      toSing+        (F (b :: Demote a) (b :: Demote b) (b :: Demote c) (b :: Demote d))+        = case+              ((((,,,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b))+                 (toSing b :: SomeSing c))+                (toSing b :: SomeSing d)+          of {+            (,,,) (SomeSing c) (SomeSing c) (SomeSing c) (SomeSing c)+              -> SomeSing ((((SF c) c) c) c) }+    instance SOrd Nat => SOrd Nat where+      sCompare ::+        forall (t1 :: Nat) (t2 :: Nat).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun Nat ((~>) Nat Ordering)+                                                 -> GHC.Types.Type) t1) t2)+      sCompare SZero SZero+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            SNil+      sCompare+        (SSucc (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SSucc (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               SNil)+      sCompare SZero (SSucc _) = SLT+      sCompare (SSucc _) SZero = SGT+    instance (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)+                                                 -> GHC.Types.Type) t1) t2)+      sCompare+        (SA (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SA (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @(:@#@$)) SCons))+                      ((applySing+                          ((applySing ((singFun2 @CompareSym0) sCompare))+                             sA_0123456789876543210))+                         sB_0123456789876543210)))+                  ((applySing+                      ((applySing ((singFun2 @(:@#@$)) SCons))+                         ((applySing+                             ((applySing ((singFun2 @CompareSym0) sCompare))+                                sA_0123456789876543210))+                            sB_0123456789876543210)))+                     ((applySing+                         ((applySing ((singFun2 @(:@#@$)) SCons))+                            ((applySing+                                ((applySing ((singFun2 @CompareSym0) sCompare))+                                   sA_0123456789876543210))+                               sB_0123456789876543210)))+                        SNil))))+      sCompare+        (SB (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SB (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @(:@#@$)) SCons))+                      ((applySing+                          ((applySing ((singFun2 @CompareSym0) sCompare))+                             sA_0123456789876543210))+                         sB_0123456789876543210)))+                  ((applySing+                      ((applySing ((singFun2 @(:@#@$)) SCons))+                         ((applySing+                             ((applySing ((singFun2 @CompareSym0) sCompare))+                                sA_0123456789876543210))+                            sB_0123456789876543210)))+                     ((applySing+                         ((applySing ((singFun2 @(:@#@$)) SCons))+                            ((applySing+                                ((applySing ((singFun2 @CompareSym0) sCompare))+                                   sA_0123456789876543210))+                               sB_0123456789876543210)))+                        SNil))))+      sCompare+        (SC (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SC (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @(:@#@$)) SCons))+                      ((applySing+                          ((applySing ((singFun2 @CompareSym0) sCompare))+                             sA_0123456789876543210))+                         sB_0123456789876543210)))+                  ((applySing+                      ((applySing ((singFun2 @(:@#@$)) SCons))+                         ((applySing+                             ((applySing ((singFun2 @CompareSym0) sCompare))+                                sA_0123456789876543210))+                            sB_0123456789876543210)))+                     ((applySing+                         ((applySing ((singFun2 @(:@#@$)) SCons))+                            ((applySing+                                ((applySing ((singFun2 @CompareSym0) sCompare))+                                   sA_0123456789876543210))+                               sB_0123456789876543210)))+                        SNil))))+      sCompare+        (SD (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SD (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @(:@#@$)) SCons))+                      ((applySing+                          ((applySing ((singFun2 @CompareSym0) sCompare))+                             sA_0123456789876543210))+                         sB_0123456789876543210)))+                  ((applySing+                      ((applySing ((singFun2 @(:@#@$)) SCons))+                         ((applySing+                             ((applySing ((singFun2 @CompareSym0) sCompare))+                                sA_0123456789876543210))+                            sB_0123456789876543210)))+                     ((applySing+                         ((applySing ((singFun2 @(:@#@$)) SCons))+                            ((applySing+                                ((applySing ((singFun2 @CompareSym0) sCompare))+                                   sA_0123456789876543210))+                               sB_0123456789876543210)))+                        SNil))))+      sCompare+        (SE (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SE (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @(:@#@$)) SCons))+                      ((applySing+                          ((applySing ((singFun2 @CompareSym0) sCompare))+                             sA_0123456789876543210))+                         sB_0123456789876543210)))+                  ((applySing+                      ((applySing ((singFun2 @(:@#@$)) SCons))+                         ((applySing+                             ((applySing ((singFun2 @CompareSym0) sCompare))+                                sA_0123456789876543210))+                            sB_0123456789876543210)))+                     ((applySing+                         ((applySing ((singFun2 @(:@#@$)) SCons))+                            ((applySing+                                ((applySing ((singFun2 @CompareSym0) sCompare))+                                   sA_0123456789876543210))+                               sB_0123456789876543210)))+                        SNil))))+      sCompare+        (SF (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210)+            (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SF (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210)+            (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @(:@#@$)) SCons))+                      ((applySing+                          ((applySing ((singFun2 @CompareSym0) sCompare))+                             sA_0123456789876543210))+                         sB_0123456789876543210)))+                  ((applySing+                      ((applySing ((singFun2 @(:@#@$)) SCons))+                         ((applySing+                             ((applySing ((singFun2 @CompareSym0) sCompare))+                                sA_0123456789876543210))+                            sB_0123456789876543210)))+                     ((applySing+                         ((applySing ((singFun2 @(:@#@$)) SCons))+                            ((applySing+                                ((applySing ((singFun2 @CompareSym0) sCompare))+                                   sA_0123456789876543210))+                               sB_0123456789876543210)))+                        SNil))))+      sCompare (SA _ _ _ _) (SB _ _ _ _) = SLT+      sCompare (SA _ _ _ _) (SC _ _ _ _) = SLT+      sCompare (SA _ _ _ _) (SD _ _ _ _) = SLT+      sCompare (SA _ _ _ _) (SE _ _ _ _) = SLT+      sCompare (SA _ _ _ _) (SF _ _ _ _) = SLT+      sCompare (SB _ _ _ _) (SA _ _ _ _) = SGT+      sCompare (SB _ _ _ _) (SC _ _ _ _) = SLT+      sCompare (SB _ _ _ _) (SD _ _ _ _) = SLT+      sCompare (SB _ _ _ _) (SE _ _ _ _) = SLT+      sCompare (SB _ _ _ _) (SF _ _ _ _) = SLT+      sCompare (SC _ _ _ _) (SA _ _ _ _) = SGT+      sCompare (SC _ _ _ _) (SB _ _ _ _) = SGT+      sCompare (SC _ _ _ _) (SD _ _ _ _) = SLT+      sCompare (SC _ _ _ _) (SE _ _ _ _) = SLT+      sCompare (SC _ _ _ _) (SF _ _ _ _) = SLT+      sCompare (SD _ _ _ _) (SA _ _ _ _) = SGT+      sCompare (SD _ _ _ _) (SB _ _ _ _) = SGT+      sCompare (SD _ _ _ _) (SC _ _ _ _) = SGT+      sCompare (SD _ _ _ _) (SE _ _ _ _) = SLT+      sCompare (SD _ _ _ _) (SF _ _ _ _) = SLT+      sCompare (SE _ _ _ _) (SA _ _ _ _) = SGT+      sCompare (SE _ _ _ _) (SB _ _ _ _) = SGT+      sCompare (SE _ _ _ _) (SC _ _ _ _) = SGT+      sCompare (SE _ _ _ _) (SD _ _ _ _) = SGT+      sCompare (SE _ _ _ _) (SF _ _ _ _) = SLT+      sCompare (SF _ _ _ _) (SA _ _ _ _) = SGT+      sCompare (SF _ _ _ _) (SB _ _ _ _) = SGT+      sCompare (SF _ _ _ _) (SC _ _ _ _) = SGT+      sCompare (SF _ _ _ _) (SD _ _ _ _) = SGT+      sCompare (SF _ _ _ _) (SE _ _ _ _) = SGT+    instance SEq Nat => SEq Nat where+      (%==) SZero SZero = STrue+      (%==) SZero (SSucc _) = SFalse+      (%==) (SSucc _) SZero = SFalse+      (%==) (SSucc a) (SSucc b) = ((%==) a) b+    instance SDecide Nat => SDecide Nat where+      (%~) SZero SZero = Proved Refl+      (%~) SZero (SSucc _) = Disproved (\ x -> case x of)+      (%~) (SSucc _) SZero = Disproved (\ x -> case x of)+      (%~) (SSucc a) (SSucc b)+        = case ((%~) a) b of+            Proved Refl -> Proved Refl+            Disproved contra+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+    instance SDecide Nat =>+             Data.Type.Equality.TestEquality (SNat :: Nat+                                                      -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance SDecide Nat =>+             Data.Type.Coercion.TestCoercion (SNat :: Nat+                                                      -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance (SEq a, SEq b, SEq c, SEq d) => SEq (Foo a b c d) where+      (%==) (SA a a a a) (SA b b b b)+        = ((%&&) (((%==) a) b))+            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))+      (%==) (SA _ _ _ _) (SB _ _ _ _) = SFalse+      (%==) (SA _ _ _ _) (SC _ _ _ _) = SFalse+      (%==) (SA _ _ _ _) (SD _ _ _ _) = SFalse+      (%==) (SA _ _ _ _) (SE _ _ _ _) = SFalse+      (%==) (SA _ _ _ _) (SF _ _ _ _) = SFalse+      (%==) (SB _ _ _ _) (SA _ _ _ _) = SFalse+      (%==) (SB a a a a) (SB b b b b)+        = ((%&&) (((%==) a) b))+            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))+      (%==) (SB _ _ _ _) (SC _ _ _ _) = SFalse+      (%==) (SB _ _ _ _) (SD _ _ _ _) = SFalse+      (%==) (SB _ _ _ _) (SE _ _ _ _) = SFalse+      (%==) (SB _ _ _ _) (SF _ _ _ _) = SFalse+      (%==) (SC _ _ _ _) (SA _ _ _ _) = SFalse+      (%==) (SC _ _ _ _) (SB _ _ _ _) = SFalse+      (%==) (SC a a a a) (SC b b b b)+        = ((%&&) (((%==) a) b))+            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))+      (%==) (SC _ _ _ _) (SD _ _ _ _) = SFalse+      (%==) (SC _ _ _ _) (SE _ _ _ _) = SFalse+      (%==) (SC _ _ _ _) (SF _ _ _ _) = SFalse+      (%==) (SD _ _ _ _) (SA _ _ _ _) = SFalse+      (%==) (SD _ _ _ _) (SB _ _ _ _) = SFalse+      (%==) (SD _ _ _ _) (SC _ _ _ _) = SFalse+      (%==) (SD a a a a) (SD b b b b)+        = ((%&&) (((%==) a) b))+            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))+      (%==) (SD _ _ _ _) (SE _ _ _ _) = SFalse+      (%==) (SD _ _ _ _) (SF _ _ _ _) = SFalse+      (%==) (SE _ _ _ _) (SA _ _ _ _) = SFalse+      (%==) (SE _ _ _ _) (SB _ _ _ _) = SFalse+      (%==) (SE _ _ _ _) (SC _ _ _ _) = SFalse+      (%==) (SE _ _ _ _) (SD _ _ _ _) = SFalse+      (%==) (SE a a a a) (SE b b b b)+        = ((%&&) (((%==) a) b))+            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))+      (%==) (SE _ _ _ _) (SF _ _ _ _) = SFalse+      (%==) (SF _ _ _ _) (SA _ _ _ _) = SFalse+      (%==) (SF _ _ _ _) (SB _ _ _ _) = SFalse+      (%==) (SF _ _ _ _) (SC _ _ _ _) = SFalse+      (%==) (SF _ _ _ _) (SD _ _ _ _) = SFalse+      (%==) (SF _ _ _ _) (SE _ _ _ _) = SFalse+      (%==) (SF a a a a) (SF b b b b)+        = ((%&&) (((%==) a) b))+            (((%&&) (((%==) a) b)) (((%&&) (((%==) a) b)) (((%==) a) b)))+    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>+             SDecide (Foo a b c d) where+      (%~) (SA a a a a) (SA b b b b)+        = case+              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)+          of+            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)+              -> Proved Refl+            (,,,) (Disproved contra) _ _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ (Disproved contra) _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ (Disproved contra) _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ _ (Disproved contra)+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+      (%~) (SA _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SA _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SA _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SA _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SA _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SB _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SB a a a a) (SB b b b b)+        = case+              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)+          of+            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)+              -> Proved Refl+            (,,,) (Disproved contra) _ _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ (Disproved contra) _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ (Disproved contra) _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ _ (Disproved contra)+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+      (%~) (SB _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SB _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SB _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SB _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SC _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SC _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SC a a a a) (SC b b b b)+        = case+              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)+          of+            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)+              -> Proved Refl+            (,,,) (Disproved contra) _ _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ (Disproved contra) _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ (Disproved contra) _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ _ (Disproved contra)+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+      (%~) (SC _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SC _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SC _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SD _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SD _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SD _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SD a a a a) (SD b b b b)+        = case+              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)+          of+            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)+              -> Proved Refl+            (,,,) (Disproved contra) _ _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ (Disproved contra) _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ (Disproved contra) _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ _ (Disproved contra)+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+      (%~) (SD _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SD _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SE _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SE _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SE _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SE _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SE a a a a) (SE b b b b)+        = case+              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)+          of+            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)+              -> Proved Refl+            (,,,) (Disproved contra) _ _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ (Disproved contra) _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ (Disproved contra) _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ _ (Disproved contra)+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+      (%~) (SE _ _ _ _) (SF _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SF _ _ _ _) (SA _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SF _ _ _ _) (SB _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SF _ _ _ _) (SC _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SF _ _ _ _) (SD _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SF _ _ _ _) (SE _ _ _ _) = Disproved (\ x -> case x of)+      (%~) (SF a a a a) (SF b b b b)+        = case+              ((((,,,) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)) (((%~) a) b)+          of+            (,,,) (Proved Refl) (Proved Refl) (Proved Refl) (Proved Refl)+              -> Proved Refl+            (,,,) (Disproved contra) _ _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ (Disproved contra) _ _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ (Disproved contra) _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,,,) _ _ _ (Disproved contra)+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>+             Data.Type.Equality.TestEquality (SFoo :: Foo a b c d+                                                      -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance (SDecide a, SDecide b, SDecide c, SDecide d) =>+             Data.Type.Coercion.TestCoercion (SFoo :: Foo a b c d+                                                      -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance SingI Zero where+      sing = SZero+    instance SingI n => SingI (Succ (n :: Nat)) where+      sing = SSucc sing+    instance SingI (SuccSym0 :: (~>) Nat Nat) where+      sing = (singFun1 @SuccSym0) SSucc+    instance (SingI n, SingI n, SingI n, SingI n) =>+             SingI (A (n :: a) (n :: b) (n :: c) (n :: d)) where+      sing = (((SA sing) sing) sing) sing+    instance SingI (ASym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where+      sing = (singFun4 @ASym0) SA+    instance SingI d =>+             SingI (ASym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where+      sing = (singFun3 @(ASym1 (d :: a))) (SA (sing @d))+    instance (SingI d, SingI d) =>+             SingI (ASym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where+      sing+        = (singFun2 @(ASym2 (d :: a) (d :: b))) ((SA (sing @d)) (sing @d))+    instance (SingI d, SingI d, SingI d) =>+             SingI (ASym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where+      sing+        = (singFun1 @(ASym3 (d :: a) (d :: b) (d :: c)))+            (((SA (sing @d)) (sing @d)) (sing @d))+    instance (SingI n, SingI n, SingI n, SingI n) =>+             SingI (B (n :: a) (n :: b) (n :: c) (n :: d)) where+      sing = (((SB sing) sing) sing) sing+    instance SingI (BSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where+      sing = (singFun4 @BSym0) SB+    instance SingI d =>+             SingI (BSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where+      sing = (singFun3 @(BSym1 (d :: a))) (SB (sing @d))+    instance (SingI d, SingI d) =>+             SingI (BSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where+      sing+        = (singFun2 @(BSym2 (d :: a) (d :: b))) ((SB (sing @d)) (sing @d))+    instance (SingI d, SingI d, SingI d) =>+             SingI (BSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where+      sing+        = (singFun1 @(BSym3 (d :: a) (d :: b) (d :: c)))+            (((SB (sing @d)) (sing @d)) (sing @d))+    instance (SingI n, SingI n, SingI n, SingI n) =>+             SingI (C (n :: a) (n :: b) (n :: c) (n :: d)) where+      sing = (((SC sing) sing) sing) sing+    instance SingI (CSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where+      sing = (singFun4 @CSym0) SC+    instance SingI d =>+             SingI (CSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where+      sing = (singFun3 @(CSym1 (d :: a))) (SC (sing @d))+    instance (SingI d, SingI d) =>+             SingI (CSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where+      sing+        = (singFun2 @(CSym2 (d :: a) (d :: b))) ((SC (sing @d)) (sing @d))+    instance (SingI d, SingI d, SingI d) =>+             SingI (CSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where+      sing+        = (singFun1 @(CSym3 (d :: a) (d :: b) (d :: c)))+            (((SC (sing @d)) (sing @d)) (sing @d))+    instance (SingI n, SingI n, SingI n, SingI n) =>+             SingI (D (n :: a) (n :: b) (n :: c) (n :: d)) where+      sing = (((SD sing) sing) sing) sing+    instance SingI (DSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where+      sing = (singFun4 @DSym0) SD+    instance SingI d =>+             SingI (DSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where+      sing = (singFun3 @(DSym1 (d :: a))) (SD (sing @d))+    instance (SingI d, SingI d) =>+             SingI (DSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where+      sing+        = (singFun2 @(DSym2 (d :: a) (d :: b))) ((SD (sing @d)) (sing @d))+    instance (SingI d, SingI d, SingI d) =>+             SingI (DSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where+      sing+        = (singFun1 @(DSym3 (d :: a) (d :: b) (d :: c)))+            (((SD (sing @d)) (sing @d)) (sing @d))+    instance (SingI n, SingI n, SingI n, SingI n) =>+             SingI (E (n :: a) (n :: b) (n :: c) (n :: d)) where+      sing = (((SE sing) sing) sing) sing+    instance SingI (ESym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where+      sing = (singFun4 @ESym0) SE+    instance SingI d =>+             SingI (ESym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where+      sing = (singFun3 @(ESym1 (d :: a))) (SE (sing @d))+    instance (SingI d, SingI d) =>+             SingI (ESym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where+      sing+        = (singFun2 @(ESym2 (d :: a) (d :: b))) ((SE (sing @d)) (sing @d))+    instance (SingI d, SingI d, SingI d) =>+             SingI (ESym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where+      sing+        = (singFun1 @(ESym3 (d :: a) (d :: b) (d :: c)))+            (((SE (sing @d)) (sing @d)) (sing @d))+    instance (SingI n, SingI n, SingI n, SingI n) =>+             SingI (F (n :: a) (n :: b) (n :: c) (n :: d)) where+      sing = (((SF sing) sing) sing) sing+    instance SingI (FSym0 :: (~>) a ((~>) b ((~>) c ((~>) d (Foo a b c d))))) where+      sing = (singFun4 @FSym0) SF+    instance SingI d =>+             SingI (FSym1 (d :: a) :: (~>) b ((~>) c ((~>) d (Foo a b c d)))) where+      sing = (singFun3 @(FSym1 (d :: a))) (SF (sing @d))+    instance (SingI d, SingI d) =>+             SingI (FSym2 (d :: a) (d :: b) :: (~>) c ((~>) d (Foo a b c d))) where+      sing+        = (singFun2 @(FSym2 (d :: a) (d :: b))) ((SF (sing @d)) (sing @d))+    instance (SingI d, SingI d, SingI d) =>+             SingI (FSym3 (d :: a) (d :: b) (d :: c) :: (~>) d (Foo a b c d)) where+      sing+        = (singFun1 @(FSym3 (d :: a) (d :: b) (d :: c)))+            (((SF (sing @d)) (sing @d)) (sing @d))
− tests/compile-and-dump/Singletons/OverloadedStrings.ghc86.template 
@@ -1,35 +0,0 @@-Singletons/OverloadedStrings.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| symId :: Symbol -> Symbol-          symId x = x-          foo :: Symbol-          foo = symId "foo" |]-  ======>-    symId :: Symbol -> Symbol-    symId x = x-    foo :: Symbol-    foo = symId "foo"-    type SymIdSym1 (a0123456789876543210 :: Symbol) =-        SymId a0123456789876543210-    instance SuppressUnusedWarnings SymIdSym0 where-      suppressUnusedWarnings = snd (((,) SymIdSym0KindInference) ())-    data SymIdSym0 :: (~>) Symbol Symbol-      where-        SymIdSym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply SymIdSym0 arg) (SymIdSym1 arg) =>-                                  SymIdSym0 a0123456789876543210-    type instance Apply SymIdSym0 a0123456789876543210 = SymId a0123456789876543210-    type FooSym0 = Foo-    type family SymId (a :: Symbol) :: Symbol where-      SymId x = x-    type family Foo :: Symbol where-      Foo = Apply SymIdSym0 (Data.Singletons.Prelude.IsString.FromString "foo")-    sSymId ::-      forall (t :: Symbol). Sing t -> Sing (Apply SymIdSym0 t :: Symbol)-    sFoo :: Sing (FooSym0 :: Symbol)-    sSymId (sX :: Sing x) = sX-    sFoo-      = (applySing ((singFun1 @SymIdSym0) sSymId))-          (Data.Singletons.Prelude.IsString.sFromString (sing :: Sing "foo"))-    instance SingI (SymIdSym0 :: (~>) Symbol Symbol) where-      sing = (singFun1 @SymIdSym0) sSymId
+ tests/compile-and-dump/Singletons/OverloadedStrings.ghc88.template view
@@ -0,0 +1,35 @@+Singletons/OverloadedStrings.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| symId :: Symbol -> Symbol+          symId x = x+          foo :: Symbol+          foo = symId "foo" |]+  ======>+    symId :: Symbol -> Symbol+    symId x = x+    foo :: Symbol+    foo = symId "foo"+    type FooSym0 = Foo+    type SymIdSym1 (a0123456789876543210 :: Symbol) =+        SymId a0123456789876543210+    instance SuppressUnusedWarnings SymIdSym0 where+      suppressUnusedWarnings = snd (((,) SymIdSym0KindInference) ())+    data SymIdSym0 :: (~>) Symbol Symbol+      where+        SymIdSym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply SymIdSym0 arg) (SymIdSym1 arg) =>+                                  SymIdSym0 a0123456789876543210+    type instance Apply SymIdSym0 a0123456789876543210 = SymId a0123456789876543210+    type family Foo :: Symbol where+      Foo = Apply SymIdSym0 (Data.Singletons.Prelude.IsString.FromString "foo")+    type family SymId (a :: Symbol) :: Symbol where+      SymId x = x+    sFoo :: Sing (FooSym0 :: Symbol)+    sSymId ::+      forall (t :: Symbol). Sing t -> Sing (Apply SymIdSym0 t :: Symbol)+    sFoo+      = (applySing ((singFun1 @SymIdSym0) sSymId))+          (Data.Singletons.Prelude.IsString.sFromString (sing :: Sing "foo"))+    sSymId (sX :: Sing x) = sX+    instance SingI (SymIdSym0 :: (~>) Symbol Symbol) where+      sing = (singFun1 @SymIdSym0) sSymId
− tests/compile-and-dump/Singletons/PatternMatching.ghc86.template 
@@ -1,574 +0,0 @@-Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| pr = Pair (Succ Zero) ([Zero])-          complex = Pair (Pair (Just Zero) Zero) False-          tuple = (False, Just Zero, True)-          aList = [Zero, Succ Zero, Succ (Succ Zero)]-          -          data Pair a b-            = Pair a b-            deriving Show |]-  ======>-    data Pair a b-      = Pair a b-      deriving Show-    pr = (Pair (Succ Zero)) [Zero]-    complex = (Pair ((Pair (Just Zero)) Zero)) False-    tuple = (False, Just Zero, True)-    aList = [Zero, Succ Zero, Succ (Succ Zero)]-    type PairSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =-        Pair t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (PairSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())-    data PairSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210)-      where-        PairSym1KindInference :: forall t0123456789876543210-                                        t0123456789876543210-                                        arg. SameKind (Apply (PairSym1 t0123456789876543210) arg) (PairSym2 t0123456789876543210 arg) =>-                                 PairSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (PairSym1 t0123456789876543210) t0123456789876543210 = Pair t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings PairSym0 where-      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())-    data PairSym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210))-      where-        PairSym0KindInference :: forall t0123456789876543210-                                        arg. SameKind (Apply PairSym0 arg) (PairSym1 arg) =>-                                 PairSym0 t0123456789876543210-    type instance Apply PairSym0 t0123456789876543210 = PairSym1 t0123456789876543210-    type AListSym0 = AList-    type TupleSym0 = Tuple-    type ComplexSym0 = Complex-    type PrSym0 = Pr-    type family AList where-      AList = Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[]))-    type family Tuple where-      Tuple = Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0-    type family Complex where-      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) '[])-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a0123456789876543210 b0123456789876543210) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210-                                                                                             b0123456789876543210.-                                                                                      (~>) (Pair a0123456789876543210 b0123456789876543210) ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210-                                                     b0123456789876543210.-                                              (~>) GHC.Types.Nat ((~>) (Pair a0123456789876543210 b0123456789876543210) ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    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-    sAList-      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))-          ((applySing-              ((applySing ((singFun2 @(:@#@$)) SCons))-                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((singFun1 @SuccSym0) SSucc))-                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))-                SNil))-    sTuple-      = (applySing-           ((applySing ((applySing ((singFun3 @Tuple3Sym0) STuple3)) SFalse))-              ((applySing ((singFun1 @JustSym0) SJust)) SZero)))-          STrue-    sComplex-      = (applySing-           ((applySing ((singFun2 @PairSym0) SPair))-              ((applySing-                  ((applySing ((singFun2 @PairSym0) SPair))-                     ((applySing ((singFun1 @JustSym0) SJust)) SZero)))-                 SZero)))-          SFalse-    sPr-      = (applySing-           ((applySing ((singFun2 @PairSym0) SPair))-              ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero)) SNil)-    data instance Sing :: Pair a b -> GHC.Types.Type-      where-        SPair :: forall a b (n :: a) (n :: b).-                 (Sing (n :: a)) -> (Sing (n :: b)) -> Sing (Pair n n)-    type SPair = (Sing :: Pair a b -> GHC.Types.Type)-    instance (SingKind a, SingKind b) => SingKind (Pair a b) where-      type Demote (Pair a b) = Pair (Demote a) (Demote b)-      fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b)-      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) }-    instance (SShow a, SShow b) => SShow (Pair a b) where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Pair a b) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SPair (sArg_0123456789876543210 :: Sing arg_0123456789876543210)-               (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "Pair "))))-                   ((applySing-                       ((applySing ((singFun3 @(.@#@$)) (%.)))-                          ((applySing-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                 (sFromInteger (sing :: Sing 11))))-                             sArg_0123456789876543210)))-                      ((applySing-                          ((applySing ((singFun3 @(.@#@$)) (%.)))-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))-                         ((applySing-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                (sFromInteger (sing :: Sing 11))))-                            sArg_0123456789876543210))))))-            sA_0123456789876543210-    deriving instance (Data.Singletons.ShowSing.ShowSing a,-                       Data.Singletons.ShowSing.ShowSing b) =>-                      Show (Sing (z :: Pair a b))-    instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where-      sing = (SPair sing) sing-    instance SingI (PairSym0 :: (~>) a ((~>) b (Pair a b))) where-      sing = (singFun2 @PairSym0) SPair-    instance SingI (TyCon2 Pair :: (~>) a ((~>) b (Pair a b))) where-      sing = (singFun2 @(TyCon2 Pair)) SPair-    instance SingI d =>-             SingI (PairSym1 (d :: a) :: (~>) b (Pair a b)) where-      sing = (singFun1 @(PairSym1 (d :: a))) (SPair (sing @d))-    instance SingI d =>-             SingI (TyCon1 (Pair (d :: a)) :: (~>) b (Pair a b)) where-      sing = (singFun1 @(TyCon1 (Pair (d :: a)))) (SPair (sing @d))-Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| Pair sz lz = pr-          Pair (Pair jz zz) fls = complex-          (tf, tjz, tt) = tuple-          [_, lsz, (Succ blimy)] = aList-          lsz :: Nat-          fls :: Bool-          foo1 :: (a, b) -> a-          foo1 (x, y) = (\ _ -> x) y-          foo2 :: (# a, b #) -> a-          foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b }-          silly :: a -> ()-          silly x = case x of { _ -> () } |]-  ======>-    Pair sz lz = pr-    Pair (Pair jz zz) fls = complex-    (tf, tjz, tt) = tuple-    [_, lsz, Succ blimy] = aList-    lsz :: Nat-    fls :: Bool-    foo1 :: (a, b) -> a-    foo1 (x, y) = (\ _ -> x) y-    foo2 :: (# a, b #) -> a-    foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b }-    silly :: a -> ()-    silly x = case x of { _ -> () }-    type family Case_0123456789876543210 x t where-      Case_0123456789876543210 x _ = Tuple0Sym0-    type Let0123456789876543210TSym2 x0123456789876543210 y0123456789876543210 =-        Let0123456789876543210T x0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210TSym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210TSym1KindInference) ())-    data Let0123456789876543210TSym1 x0123456789876543210 y0123456789876543210-      where-        Let0123456789876543210TSym1KindInference :: forall x0123456789876543210-                                                           y0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210TSym1 x0123456789876543210) arg) (Let0123456789876543210TSym2 x0123456789876543210 arg) =>-                                                    Let0123456789876543210TSym1 x0123456789876543210 y0123456789876543210-    type instance Apply (Let0123456789876543210TSym1 x0123456789876543210) y0123456789876543210 = Let0123456789876543210T x0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210TSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210TSym0KindInference) ())-    data Let0123456789876543210TSym0 x0123456789876543210-      where-        Let0123456789876543210TSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210TSym0 arg) (Let0123456789876543210TSym1 arg) =>-                                                    Let0123456789876543210TSym0 x0123456789876543210-    type instance Apply Let0123456789876543210TSym0 x0123456789876543210 = Let0123456789876543210TSym1 x0123456789876543210-    type family Let0123456789876543210T x y where-      Let0123456789876543210T x y = Apply (Apply Tuple2Sym0 x) y-    type family Case_0123456789876543210 x y a b arg_0123456789876543210 t where-      Case_0123456789876543210 x y a b arg_0123456789876543210 _ = a-    type family Lambda_0123456789876543210 x y a b t where-      Lambda_0123456789876543210 x y a b arg_0123456789876543210 = Case_0123456789876543210 x y a b arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 b0123456789876543210 a0123456789876543210 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())-    data Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym4KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              a0123456789876543210-                                                              b0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym5 x0123456789876543210 y0123456789876543210 a0123456789876543210 b0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 a0123456789876543210 b0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym4 b0123456789876543210 a0123456789876543210 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 b0123456789876543210 a0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a0123456789876543210 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 a0123456789876543210 b0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              a0123456789876543210-                                                              b0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 a0123456789876543210) arg) (Lambda_0123456789876543210Sym4 x0123456789876543210 y0123456789876543210 a0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 a0123456789876543210 b0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 a0123456789876543210 y0123456789876543210 x0123456789876543210) b0123456789876543210 = Lambda_0123456789876543210Sym4 a0123456789876543210 y0123456789876543210 x0123456789876543210 b0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 a0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              a0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 a0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) a0123456789876543210 = Lambda_0123456789876543210Sym3 y0123456789876543210 x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Case_0123456789876543210 x y t where-      Case_0123456789876543210 x y '(a,-                                     b) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) a) b) b-    type family Case_0123456789876543210 x y arg_0123456789876543210 t where-      Case_0123456789876543210 x y arg_0123456789876543210 _ = x-    type family Lambda_0123456789876543210 x y t where-      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 x y arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              y0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Case_0123456789876543210 t where-      Case_0123456789876543210 '[_,-                                 y_0123456789876543210,-                                  'Succ _] = y_0123456789876543210-    type family Case_0123456789876543210 t where-      Case_0123456789876543210 '[_,-                                 _,-                                  'Succ 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 '(_,-                                 _,-                                 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-    type SillySym1 (a0123456789876543210 :: a0123456789876543210) =-        Silly a0123456789876543210-    instance SuppressUnusedWarnings SillySym0 where-      suppressUnusedWarnings = snd (((,) SillySym0KindInference) ())-    data SillySym0 :: forall a0123456789876543210.-                      (~>) a0123456789876543210 ()-      where-        SillySym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply SillySym0 arg) (SillySym1 arg) =>-                                  SillySym0 a0123456789876543210-    type instance Apply SillySym0 a0123456789876543210 = Silly a0123456789876543210-    type Foo2Sym1 (a0123456789876543210 :: (a0123456789876543210,-                                            b0123456789876543210)) =-        Foo2 a0123456789876543210-    instance SuppressUnusedWarnings Foo2Sym0 where-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())-    data Foo2Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) (a0123456789876543210,-                           b0123456789876543210) a0123456789876543210-      where-        Foo2Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>-                                 Foo2Sym0 a0123456789876543210-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2 a0123456789876543210-    type Foo1Sym1 (a0123456789876543210 :: (a0123456789876543210,-                                            b0123456789876543210)) =-        Foo1 a0123456789876543210-    instance SuppressUnusedWarnings Foo1Sym0 where-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())-    data Foo1Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) (a0123456789876543210,-                           b0123456789876543210) a0123456789876543210-      where-        Foo1Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>-                                 Foo1Sym0 a0123456789876543210-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210-    type LszSym0 = Lsz-    type BlimySym0 = Blimy-    type TfSym0 = Tf-    type TjzSym0 = Tjz-    type TtSym0 = Tt-    type JzSym0 = Jz-    type ZzSym0 = Zz-    type FlsSym0 = Fls-    type SzSym0 = Sz-    type LzSym0 = Lz-    type X_0123456789876543210Sym0 = X_0123456789876543210-    type X_0123456789876543210Sym0 = X_0123456789876543210-    type X_0123456789876543210Sym0 = X_0123456789876543210-    type X_0123456789876543210Sym0 = X_0123456789876543210-    type family Silly (a :: a) :: () where-      Silly x = Case_0123456789876543210 x x-    type family Foo2 (a :: (a, b)) :: a where-      Foo2 '(x,-             y) = Case_0123456789876543210 x y (Let0123456789876543210TSym2 x y)-    type family Foo1 (a :: (a, b)) :: a where-      Foo1 '(x,-             y) = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y-    type family Lsz :: Nat where-      Lsz = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Blimy where-      Blimy = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Tf where-      Tf = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Tjz where-      Tjz = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Tt where-      Tt = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Jz where-      Jz = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Zz where-      Zz = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Fls :: Bool where-      Fls = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Sz where-      Sz = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Lz where-      Lz = Case_0123456789876543210 X_0123456789876543210Sym0-    type family X_0123456789876543210 where-      X_0123456789876543210 = PrSym0-    type family X_0123456789876543210 where-      X_0123456789876543210 = ComplexSym0-    type family X_0123456789876543210 where-      X_0123456789876543210 = TupleSym0-    type family X_0123456789876543210 where-      X_0123456789876543210 = AListSym0-    sSilly ::-      forall a (t :: a). Sing t -> Sing (Apply SillySym0 t :: ())-    sFoo2 ::-      forall a b (t :: (a, b)). Sing t -> Sing (Apply Foo2Sym0 t :: a)-    sFoo1 ::-      forall a b (t :: (a, b)). Sing t -> Sing (Apply Foo1Sym0 t :: a)-    sLsz :: Sing (LszSym0 :: Nat)-    sBlimy :: Sing BlimySym0-    sTf :: Sing TfSym0-    sTjz :: Sing TjzSym0-    sTt :: Sing TtSym0-    sJz :: Sing JzSym0-    sZz :: Sing ZzSym0-    sFls :: Sing (FlsSym0 :: Bool)-    sSz :: Sing SzSym0-    sLz :: Sing LzSym0-    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0-    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0-    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0-    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0-    sSilly (sX :: Sing x)-      = (case sX of { _ -> STuple0 }) ::-          Sing (Case_0123456789876543210 x x :: ())-    sFoo2 (STuple2 (sX :: Sing x) (sY :: Sing y))-      = let-          sT :: Sing (Let0123456789876543210TSym2 x y)-          sT-            = (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX)) sY-        in  (case sT of {-               STuple2 (sA :: Sing a) (sB :: Sing b)-                 -> (applySing-                       ((singFun1-                           @(Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) a) b))-                          (\ sArg_0123456789876543210-                             -> case sArg_0123456789876543210 of {-                                  (_ :: Sing arg_0123456789876543210)-                                    -> (case sArg_0123456789876543210 of { _ -> sA }) ::-                                         Sing (Case_0123456789876543210 x y a b arg_0123456789876543210 arg_0123456789876543210) })))-                      sB }) ::-              Sing (Case_0123456789876543210 x y (Let0123456789876543210TSym2 x y) :: a)-    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)-                        -> (case sArg_0123456789876543210 of { _ -> sX }) ::-                             Sing (Case_0123456789876543210 x y arg_0123456789876543210 arg_0123456789876543210) })))-          sY-    sLsz-      = (case sX_0123456789876543210 of {-           SCons _-                 (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)-                        (SCons (SSucc _) SNil))-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Nat)-    sBlimy-      = (case sX_0123456789876543210 of {-           SCons _-                 (SCons _-                        (SCons (SSucc (sY_0123456789876543210 :: Sing y_0123456789876543210))-                               SNil))-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0)-    sTf-      = (case sX_0123456789876543210 of {-           STuple3 (sY_0123456789876543210 :: Sing y_0123456789876543210) _ _-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0)-    sTjz-      = (case sX_0123456789876543210 of {-           STuple3 _ (sY_0123456789876543210 :: Sing y_0123456789876543210) _-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0)-    sTt-      = (case sX_0123456789876543210 of {-           STuple3 _ _ (sY_0123456789876543210 :: Sing y_0123456789876543210)-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0)-    sJz-      = (case sX_0123456789876543210 of {-           SPair (SPair (sY_0123456789876543210 :: Sing y_0123456789876543210)-                        _)-                 _-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0)-    sZz-      = (case sX_0123456789876543210 of {-           SPair (SPair _-                        (sY_0123456789876543210 :: Sing y_0123456789876543210))-                 _-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0)-    sFls-      = (case sX_0123456789876543210 of {-           SPair (SPair _ _)-                 (sY_0123456789876543210 :: Sing y_0123456789876543210)-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)-    sSz-      = (case sX_0123456789876543210 of {-           SPair (sY_0123456789876543210 :: Sing y_0123456789876543210) _-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0)-    sLz-      = (case sX_0123456789876543210 of {-           SPair _ (sY_0123456789876543210 :: Sing y_0123456789876543210)-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0)-    sX_0123456789876543210 = sPr-    sX_0123456789876543210 = sComplex-    sX_0123456789876543210 = sTuple-    sX_0123456789876543210 = sAList-    instance SingI (SillySym0 :: (~>) a ()) where-      sing = (singFun1 @SillySym0) sSilly-    instance SingI (Foo2Sym0 :: (~>) (a, b) a) where-      sing = (singFun1 @Foo2Sym0) sFoo2-    instance SingI (Foo1Sym0 :: (~>) (a, b) a) where-      sing = (singFun1 @Foo1Sym0) sFoo1
+ tests/compile-and-dump/Singletons/PatternMatching.ghc88.template view
@@ -0,0 +1,587 @@+Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| pr = Pair (Succ Zero) ([Zero])+          complex = Pair (Pair (Just Zero) Zero) False+          tuple = (False, Just Zero, True)+          aList = [Zero, Succ Zero, Succ (Succ Zero)]+          +          data Pair a b+            = Pair a b+            deriving Show |]+  ======>+    data Pair a b+      = Pair a b+      deriving Show+    pr = (Pair (Succ Zero)) [Zero]+    complex = (Pair ((Pair (Just Zero)) Zero)) False+    tuple = (False, Just Zero, True)+    aList = [Zero, Succ Zero, Succ (Succ Zero)]+    type PairSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =+        Pair t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (PairSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) PairSym1KindInference) ())+    data PairSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210)+      where+        PairSym1KindInference :: forall t0123456789876543210+                                        t0123456789876543210+                                        arg. SameKind (Apply (PairSym1 t0123456789876543210) arg) (PairSym2 t0123456789876543210 arg) =>+                                 PairSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (PairSym1 t0123456789876543210) t0123456789876543210 = Pair t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings PairSym0 where+      suppressUnusedWarnings = snd (((,) PairSym0KindInference) ())+    data PairSym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210))+      where+        PairSym0KindInference :: forall t0123456789876543210+                                        arg. SameKind (Apply PairSym0 arg) (PairSym1 arg) =>+                                 PairSym0 t0123456789876543210+    type instance Apply PairSym0 t0123456789876543210 = PairSym1 t0123456789876543210+    type AListSym0 = AList+    type TupleSym0 = Tuple+    type ComplexSym0 = Complex+    type PrSym0 = Pr+    type family AList where+      AList = Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))) '[]))+    type family Tuple where+      Tuple = Apply (Apply (Apply Tuple3Sym0 FalseSym0) (Apply JustSym0 ZeroSym0)) TrueSym0+    type family Complex where+      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) '[])+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Pair a0123456789876543210 b0123456789876543210) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210+                                                                                             b0123456789876543210.+                                                                                      (~>) (Pair a0123456789876543210 b0123456789876543210) ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210+                                                     b0123456789876543210.+                                              (~>) GHC.Types.Nat ((~>) (Pair a0123456789876543210 b0123456789876543210) ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    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+    sAList+      = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))+          ((applySing+              ((applySing ((singFun2 @(:@#@$)) SCons))+                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((singFun1 @SuccSym0) SSucc))+                       ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))+                SNil))+    sTuple+      = (applySing+           ((applySing ((applySing ((singFun3 @Tuple3Sym0) STuple3)) SFalse))+              ((applySing ((singFun1 @JustSym0) SJust)) SZero)))+          STrue+    sComplex+      = (applySing+           ((applySing ((singFun2 @PairSym0) SPair))+              ((applySing+                  ((applySing ((singFun2 @PairSym0) SPair))+                     ((applySing ((singFun1 @JustSym0) SJust)) SZero)))+                 SZero)))+          SFalse+    sPr+      = (applySing+           ((applySing ((singFun2 @PairSym0) SPair))+              ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero)) SNil)+    data SPair :: forall a b. Pair a b -> GHC.Types.Type+      where+        SPair :: forall a b (n :: a) (n :: b).+                 (Sing (n :: a)) -> (Sing (n :: b)) -> SPair (Pair n n)+    type instance Sing @(Pair a b) = SPair+    instance (SingKind a, SingKind b) => SingKind (Pair a b) where+      type Demote (Pair a b) = Pair (Demote a) (Demote b)+      fromSing (SPair b b) = (Pair (fromSing b)) (fromSing b)+      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) }+    instance (SShow a, SShow b) => SShow (Pair a b) where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Pair a b) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Pair a b) ((~>) Symbol Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SPair (sArg_0123456789876543210 :: Sing arg_0123456789876543210)+               (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "Pair "))))+                   ((applySing+                       ((applySing ((singFun3 @(.@#@$)) (%.)))+                          ((applySing+                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                 (sFromInteger (sing :: Sing 11))))+                             sArg_0123456789876543210)))+                      ((applySing+                          ((applySing ((singFun3 @(.@#@$)) (%.)))+                             ((singFun1 @ShowSpaceSym0) sShowSpace)))+                         ((applySing+                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                (sFromInteger (sing :: Sing 11))))+                            sArg_0123456789876543210))))))+            sA_0123456789876543210+    instance (Data.Singletons.ShowSing.ShowSing a,+              Data.Singletons.ShowSing.ShowSing b) =>+             Show (SPair (z :: Pair a b)) where+      showsPrec+        p_0123456789876543210+        (SPair (arg_0123456789876543210 :: Sing argTy_0123456789876543210)+               (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SPair "))+               (((.) ((showsPrec 11) arg_0123456789876543210))+                  (((.) GHC.Show.showSpace)+                     ((showsPrec 11) arg_0123456789876543210)))) ::+            (Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210) =>+            ShowS+    instance (SingI n, SingI n) => SingI (Pair (n :: a) (n :: b)) where+      sing = (SPair sing) sing+    instance SingI (PairSym0 :: (~>) a ((~>) b (Pair a b))) where+      sing = (singFun2 @PairSym0) SPair+    instance SingI d =>+             SingI (PairSym1 (d :: a) :: (~>) b (Pair a b)) where+      sing = (singFun1 @(PairSym1 (d :: a))) (SPair (sing @d))+Singletons/PatternMatching.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| Pair sz lz = pr+          Pair (Pair jz zz) fls = complex+          (tf, tjz, tt) = tuple+          [_, lsz, (Succ blimy)] = aList+          lsz :: Nat+          fls :: Bool+          foo1 :: (a, b) -> a+          foo1 (x, y) = (\ _ -> x) y+          foo2 :: (# a, b #) -> a+          foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b }+          silly :: a -> ()+          silly x = case x of { _ -> () } |]+  ======>+    Pair sz lz = pr+    Pair (Pair jz zz) fls = complex+    (tf, tjz, tt) = tuple+    [_, lsz, Succ blimy] = aList+    lsz :: Nat+    fls :: Bool+    foo1 :: (a, b) -> a+    foo1 (x, y) = (\ _ -> x) y+    foo2 :: (# a, b #) -> a+    foo2 t@(# x, y #) = case t of { (# a, b #) -> (\ _ -> a) b }+    silly :: a -> ()+    silly x = case x of { _ -> () }+    type family Case_0123456789876543210 x t where+      Case_0123456789876543210 x _ = Tuple0Sym0+    type Let0123456789876543210TSym2 x0123456789876543210 y0123456789876543210 =+        Let0123456789876543210T x0123456789876543210 y0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210TSym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210TSym1KindInference) ())+    data Let0123456789876543210TSym1 x0123456789876543210 y0123456789876543210+      where+        Let0123456789876543210TSym1KindInference :: forall x0123456789876543210+                                                           y0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210TSym1 x0123456789876543210) arg) (Let0123456789876543210TSym2 x0123456789876543210 arg) =>+                                                    Let0123456789876543210TSym1 x0123456789876543210 y0123456789876543210+    type instance Apply (Let0123456789876543210TSym1 x0123456789876543210) y0123456789876543210 = Let0123456789876543210T x0123456789876543210 y0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210TSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210TSym0KindInference) ())+    data Let0123456789876543210TSym0 x0123456789876543210+      where+        Let0123456789876543210TSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210TSym0 arg) (Let0123456789876543210TSym1 arg) =>+                                                    Let0123456789876543210TSym0 x0123456789876543210+    type instance Apply Let0123456789876543210TSym0 x0123456789876543210 = Let0123456789876543210TSym1 x0123456789876543210+    type family Let0123456789876543210T x y where+      Let0123456789876543210T x y = Apply (Apply Tuple2Sym0 x) y+    type family Case_0123456789876543210 arg_0123456789876543210 a b x y t where+      Case_0123456789876543210 arg_0123456789876543210 a b x y _ = a+    type family Lambda_0123456789876543210 a b x y t where+      Lambda_0123456789876543210 a b x y arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 a b x y arg_0123456789876543210+    type Lambda_0123456789876543210Sym5 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym4 y0123456789876543210 x0123456789876543210 b0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym4KindInference) ())+    data Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym4KindInference :: forall a0123456789876543210+                                                              b0123456789876543210+                                                              x0123456789876543210+                                                              y0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym5 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym4 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym4 y0123456789876543210 x0123456789876543210 b0123456789876543210 a0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 b0123456789876543210 a0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 x0123456789876543210 b0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 x0123456789876543210 y0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall a0123456789876543210+                                                              b0123456789876543210+                                                              x0123456789876543210+                                                              y0123456789876543210+                                                              arg. 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 x0123456789876543210 b0123456789876543210 a0123456789876543210) y0123456789876543210 = Lambda_0123456789876543210Sym4 x0123456789876543210 b0123456789876543210 a0123456789876543210 y0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                              b0123456789876543210+                                                              x0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 b0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 b0123456789876543210 x0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 b0123456789876543210 a0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210Sym3 b0123456789876543210 a0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 a0123456789876543210 b0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                              b0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 a0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210+    type family Case_0123456789876543210 x y t where+      Case_0123456789876543210 x y '(a,+                                     b) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) x) y) b+    type family Case_0123456789876543210 arg_0123456789876543210 x y t where+      Case_0123456789876543210 arg_0123456789876543210 x y _ = x+    type family Lambda_0123456789876543210 x y t where+      Lambda_0123456789876543210 x y arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x y arg_0123456789876543210+    type Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 y0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 y0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 y0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 y0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 y0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 y0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              y0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    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+    type SillySym1 (a0123456789876543210 :: a0123456789876543210) =+        Silly a0123456789876543210+    instance SuppressUnusedWarnings SillySym0 where+      suppressUnusedWarnings = snd (((,) SillySym0KindInference) ())+    data SillySym0 :: forall a0123456789876543210.+                      (~>) a0123456789876543210 ()+      where+        SillySym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply SillySym0 arg) (SillySym1 arg) =>+                                  SillySym0 a0123456789876543210+    type instance Apply SillySym0 a0123456789876543210 = Silly a0123456789876543210+    type Foo2Sym1 (a0123456789876543210 :: (a0123456789876543210,+                                            b0123456789876543210)) =+        Foo2 a0123456789876543210+    instance SuppressUnusedWarnings Foo2Sym0 where+      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())+    data Foo2Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) (a0123456789876543210,+                           b0123456789876543210) a0123456789876543210+      where+        Foo2Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>+                                 Foo2Sym0 a0123456789876543210+    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2 a0123456789876543210+    type Foo1Sym1 (a0123456789876543210 :: (a0123456789876543210,+                                            b0123456789876543210)) =+        Foo1 a0123456789876543210+    instance SuppressUnusedWarnings Foo1Sym0 where+      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())+    data Foo1Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) (a0123456789876543210,+                           b0123456789876543210) a0123456789876543210+      where+        Foo1Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>+                                 Foo1Sym0 a0123456789876543210+    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210+    type BlimySym0 = Blimy+    type LszSym0 = Lsz+    type X_0123456789876543210Sym0 = X_0123456789876543210+    type TtSym0 = Tt+    type TjzSym0 = Tjz+    type TfSym0 = Tf+    type X_0123456789876543210Sym0 = X_0123456789876543210+    type FlsSym0 = Fls+    type ZzSym0 = Zz+    type JzSym0 = Jz+    type X_0123456789876543210Sym0 = X_0123456789876543210+    type LzSym0 = Lz+    type SzSym0 = Sz+    type X_0123456789876543210Sym0 = X_0123456789876543210+    type family Silly (a :: a) :: () where+      Silly x = Case_0123456789876543210 x x+    type family Foo2 (a :: (a, b)) :: a where+      Foo2 '(x,+             y) = Case_0123456789876543210 x y (Let0123456789876543210TSym2 x y)+    type family Foo1 (a :: (a, b)) :: a where+      Foo1 '(x,+             y) = Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) y) y+    type family Blimy where+      Blimy = Case_0123456789876543210 X_0123456789876543210Sym0+    type family Lsz :: Nat where+      Lsz = Case_0123456789876543210 X_0123456789876543210Sym0+    type family X_0123456789876543210 where+      X_0123456789876543210 = AListSym0+    type family Tt where+      Tt = Case_0123456789876543210 X_0123456789876543210Sym0+    type family Tjz where+      Tjz = Case_0123456789876543210 X_0123456789876543210Sym0+    type family Tf where+      Tf = Case_0123456789876543210 X_0123456789876543210Sym0+    type family X_0123456789876543210 where+      X_0123456789876543210 = TupleSym0+    type family Fls :: Bool where+      Fls = Case_0123456789876543210 X_0123456789876543210Sym0+    type family Zz where+      Zz = Case_0123456789876543210 X_0123456789876543210Sym0+    type family Jz where+      Jz = Case_0123456789876543210 X_0123456789876543210Sym0+    type family X_0123456789876543210 where+      X_0123456789876543210 = ComplexSym0+    type family Lz where+      Lz = Case_0123456789876543210 X_0123456789876543210Sym0+    type family Sz where+      Sz = Case_0123456789876543210 X_0123456789876543210Sym0+    type family X_0123456789876543210 where+      X_0123456789876543210 = PrSym0+    sSilly ::+      forall a (t :: a). Sing t -> Sing (Apply SillySym0 t :: ())+    sFoo2 ::+      forall a b (t :: (a, b)). Sing t -> Sing (Apply Foo2Sym0 t :: a)+    sFoo1 ::+      forall a b (t :: (a, b)). Sing t -> Sing (Apply Foo1Sym0 t :: a)+    sBlimy :: Sing BlimySym0+    sLsz :: Sing (LszSym0 :: Nat)+    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0+    sTt :: Sing TtSym0+    sTjz :: Sing TjzSym0+    sTf :: Sing TfSym0+    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0+    sFls :: Sing (FlsSym0 :: Bool)+    sZz :: Sing ZzSym0+    sJz :: Sing JzSym0+    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0+    sLz :: Sing LzSym0+    sSz :: Sing SzSym0+    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0+    sSilly (sX :: Sing x)+      = (id @(Sing (Case_0123456789876543210 x x :: ())))+          (case sX of { _ -> STuple0 })+    sFoo2 (STuple2 (sX :: Sing x) (sY :: Sing y))+      = let+          sT :: Sing (Let0123456789876543210TSym2 x y)+          sT+            = (applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX)) sY+        in+          (id+             @(Sing (Case_0123456789876543210 x y (Let0123456789876543210TSym2 x y) :: a)))+            (case sT of {+               STuple2 (sA :: Sing a) (sB :: Sing b)+                 -> (applySing+                       ((singFun1+                           @(Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) b) x) y))+                          (\ sArg_0123456789876543210+                             -> case sArg_0123456789876543210 of {+                                  (_ :: Sing arg_0123456789876543210)+                                    -> (id+                                          @(Sing (Case_0123456789876543210 arg_0123456789876543210 a b x y arg_0123456789876543210)))+                                         (case sArg_0123456789876543210 of { _ -> sA }) })))+                      sB })+    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 }) })))+          sY+    sBlimy+      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))+          (case sX_0123456789876543210 of {+             SCons _+                   (SCons _+                          (SCons (SSucc (sY_0123456789876543210 :: Sing y_0123456789876543210))+                                 SNil))+               -> sY_0123456789876543210 })+    sLsz+      = (id+           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Nat)))+          (case sX_0123456789876543210 of {+             SCons _+                   (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)+                          (SCons (SSucc _) SNil))+               -> sY_0123456789876543210 })+    sX_0123456789876543210 = sAList+    sTt+      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))+          (case sX_0123456789876543210 of {+             STuple3 _ _ (sY_0123456789876543210 :: Sing y_0123456789876543210)+               -> sY_0123456789876543210 })+    sTjz+      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))+          (case sX_0123456789876543210 of {+             STuple3 _ (sY_0123456789876543210 :: Sing y_0123456789876543210) _+               -> sY_0123456789876543210 })+    sTf+      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))+          (case sX_0123456789876543210 of {+             STuple3 (sY_0123456789876543210 :: Sing y_0123456789876543210) _ _+               -> sY_0123456789876543210 })+    sX_0123456789876543210 = sTuple+    sFls+      = (id+           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))+          (case sX_0123456789876543210 of {+             SPair (SPair _ _)+                   (sY_0123456789876543210 :: Sing y_0123456789876543210)+               -> sY_0123456789876543210 })+    sZz+      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))+          (case sX_0123456789876543210 of {+             SPair (SPair _+                          (sY_0123456789876543210 :: Sing y_0123456789876543210))+                   _+               -> sY_0123456789876543210 })+    sJz+      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))+          (case sX_0123456789876543210 of {+             SPair (SPair (sY_0123456789876543210 :: Sing y_0123456789876543210)+                          _)+                   _+               -> sY_0123456789876543210 })+    sX_0123456789876543210 = sComplex+    sLz+      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))+          (case sX_0123456789876543210 of {+             SPair _ (sY_0123456789876543210 :: Sing y_0123456789876543210)+               -> sY_0123456789876543210 })+    sSz+      = (id @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0)))+          (case sX_0123456789876543210 of {+             SPair (sY_0123456789876543210 :: Sing y_0123456789876543210) _+               -> sY_0123456789876543210 })+    sX_0123456789876543210 = sPr+    instance SingI (SillySym0 :: (~>) a ()) where+      sing = (singFun1 @SillySym0) sSilly+    instance SingI (Foo2Sym0 :: (~>) (a, b) a) where+      sing = (singFun1 @Foo2Sym0) sFoo2+    instance SingI (Foo1Sym0 :: (~>) (a, b) a) where+      sing = (singFun1 @Foo1Sym0) sFoo1
− tests/compile-and-dump/Singletons/PolyKinds.ghc86.template 
@@ -1,28 +0,0 @@-Singletons/PolyKinds.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| class Cls (a :: k) where-            fff :: Proxy (a :: k) -> () |]-  ======>-    class Cls (a :: k) where-      fff :: Proxy (a :: k) -> ()-    type FffSym1 (arg0123456789876543210 :: Proxy (a0123456789876543210 :: k0123456789876543210)) =-        Fff arg0123456789876543210-    instance SuppressUnusedWarnings FffSym0 where-      suppressUnusedWarnings = snd (((,) FffSym0KindInference) ())-    data FffSym0 :: forall k0123456789876543210-                           (a0123456789876543210 :: k0123456789876543210).-                    (~>) (Proxy (a0123456789876543210 :: k0123456789876543210)) ()-      where-        FffSym0KindInference :: forall arg0123456789876543210-                                       arg. SameKind (Apply FffSym0 arg) (FffSym1 arg) =>-                                FffSym0 arg0123456789876543210-    type instance Apply FffSym0 arg0123456789876543210 = Fff arg0123456789876543210-    class PCls (a :: k) where-      type Fff (arg :: Proxy (a :: k)) :: ()-    class SCls (a :: k) where-      sFff ::-        forall (t :: Proxy (a :: k)).-        Sing t -> Sing (Apply FffSym0 t :: ())-    instance SCls a =>-             SingI (FffSym0 :: (~>) (Proxy (a :: k)) ()) where-      sing = (singFun1 @FffSym0) sFff
+ tests/compile-and-dump/Singletons/PolyKinds.ghc88.template view
@@ -0,0 +1,28 @@+Singletons/PolyKinds.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| class Cls (a :: k) where+            fff :: Proxy (a :: k) -> () |]+  ======>+    class Cls (a :: k) where+      fff :: Proxy (a :: k) -> ()+    type FffSym1 (arg0123456789876543210 :: Proxy (a0123456789876543210 :: k0123456789876543210)) =+        Fff arg0123456789876543210+    instance SuppressUnusedWarnings FffSym0 where+      suppressUnusedWarnings = snd (((,) FffSym0KindInference) ())+    data FffSym0 :: forall k0123456789876543210+                           (a0123456789876543210 :: k0123456789876543210).+                    (~>) (Proxy (a0123456789876543210 :: k0123456789876543210)) ()+      where+        FffSym0KindInference :: forall arg0123456789876543210+                                       arg. SameKind (Apply FffSym0 arg) (FffSym1 arg) =>+                                FffSym0 arg0123456789876543210+    type instance Apply FffSym0 arg0123456789876543210 = Fff arg0123456789876543210+    class PCls (a :: k) where+      type Fff (arg :: Proxy (a :: k)) :: ()+    class SCls (a :: k) where+      sFff ::+        forall (t :: Proxy (a :: k)).+        Sing t -> Sing (Apply FffSym0 t :: ())+    instance SCls a =>+             SingI (FffSym0 :: (~>) (Proxy (a :: k)) ()) where+      sing = (singFun1 @FffSym0) sFff
− tests/compile-and-dump/Singletons/PolyKindsApp.ghc86.template 
@@ -1,12 +0,0 @@-Singletons/PolyKindsApp.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| class Cls (a :: k -> Type) where-            fff :: (a :: k -> Type) (b :: k) |]-  ======>-    class Cls (a :: k -> Type) where-      fff :: (a :: k -> Type) (b :: k)-    type FffSym0 = Fff-    class PCls (a :: k -> Type) where-      type Fff :: (a :: k -> Type) (b :: k)-    class SCls (a :: k -> Type) where-      sFff :: forall b. Sing (FffSym0 :: (a :: k -> Type) (b :: k))
+ tests/compile-and-dump/Singletons/PolyKindsApp.ghc88.template view
@@ -0,0 +1,12 @@+Singletons/PolyKindsApp.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| class Cls (a :: k -> Type) where+            fff :: (a :: k -> Type) (b :: k) |]+  ======>+    class Cls (a :: k -> Type) where+      fff :: (a :: k -> Type) (b :: k)+    type FffSym0 = Fff+    class PCls (a :: k -> Type) where+      type Fff :: (a :: k -> Type) (b :: k)+    class SCls (a :: k -> Type) where+      sFff :: forall b. Sing (FffSym0 :: (a :: k -> Type) (b :: k))
− tests/compile-and-dump/Singletons/Records.ghc86.template 
@@ -1,79 +0,0 @@-Singletons/Records.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Record a = MkRecord {field1 :: a, field2 :: Bool} |]-  ======>-    data Record a = MkRecord {field1 :: a, field2 :: Bool}-    type Field1Sym1 (a0123456789876543210 :: Record a0123456789876543210) =-        Field1 a0123456789876543210-    instance SuppressUnusedWarnings Field1Sym0 where-      suppressUnusedWarnings = snd (((,) Field1Sym0KindInference) ())-    data Field1Sym0 :: forall a0123456789876543210.-                       (~>) (Record a0123456789876543210) a0123456789876543210-      where-        Field1Sym0KindInference :: forall a0123456789876543210-                                          arg. SameKind (Apply Field1Sym0 arg) (Field1Sym1 arg) =>-                                   Field1Sym0 a0123456789876543210-    type instance Apply Field1Sym0 a0123456789876543210 = Field1 a0123456789876543210-    type Field2Sym1 (a0123456789876543210 :: Record a0123456789876543210) =-        Field2 a0123456789876543210-    instance SuppressUnusedWarnings Field2Sym0 where-      suppressUnusedWarnings = snd (((,) Field2Sym0KindInference) ())-    data Field2Sym0 :: forall a0123456789876543210.-                       (~>) (Record a0123456789876543210) Bool-      where-        Field2Sym0KindInference :: forall a0123456789876543210-                                          arg. SameKind (Apply Field2Sym0 arg) (Field2Sym1 arg) =>-                                   Field2Sym0 a0123456789876543210-    type instance Apply Field2Sym0 a0123456789876543210 = Field2 a0123456789876543210-    type family Field1 (a :: Record a) :: a where-      Field1 (MkRecord field _) = field-    type family Field2 (a :: Record a) :: Bool where-      Field2 (MkRecord _ field) = field-    type MkRecordSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: Bool) =-        MkRecord t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkRecordSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkRecordSym1KindInference) ())-    data MkRecordSym1 (t0123456789876543210 :: a0123456789876543210) :: (~>) Bool (Record a0123456789876543210)-      where-        MkRecordSym1KindInference :: forall t0123456789876543210-                                            t0123456789876543210-                                            arg. SameKind (Apply (MkRecordSym1 t0123456789876543210) arg) (MkRecordSym2 t0123456789876543210 arg) =>-                                     MkRecordSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (MkRecordSym1 t0123456789876543210) t0123456789876543210 = MkRecord t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings MkRecordSym0 where-      suppressUnusedWarnings = snd (((,) MkRecordSym0KindInference) ())-    data MkRecordSym0 :: forall a0123456789876543210.-                         (~>) a0123456789876543210 ((~>) Bool (Record a0123456789876543210))-      where-        MkRecordSym0KindInference :: forall t0123456789876543210-                                            arg. SameKind (Apply MkRecordSym0 arg) (MkRecordSym1 arg) =>-                                     MkRecordSym0 t0123456789876543210-    type instance Apply MkRecordSym0 t0123456789876543210 = MkRecordSym1 t0123456789876543210-    data instance Sing :: Record a -> GHC.Types.Type-      where-        SMkRecord :: forall a (n :: a) (n :: Bool).-                     {sField1 :: (Sing (n :: a)), sField2 :: (Sing (n :: Bool))}-                     -> Sing (MkRecord n n)-    type SRecord = (Sing :: Record a -> GHC.Types.Type)-    instance SingKind a => SingKind (Record a) where-      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) }-    instance (SingI n, SingI n) =>-             SingI (MkRecord (n :: a) (n :: Bool)) where-      sing = (SMkRecord sing) sing-    instance SingI (MkRecordSym0 :: (~>) a ((~>) Bool (Record a))) where-      sing = (singFun2 @MkRecordSym0) SMkRecord-    instance SingI (TyCon2 MkRecord :: (~>) a ((~>) Bool (Record a))) where-      sing = (singFun2 @(TyCon2 MkRecord)) SMkRecord-    instance SingI d =>-             SingI (MkRecordSym1 (d :: a) :: (~>) Bool (Record a)) where-      sing = (singFun1 @(MkRecordSym1 (d :: a))) (SMkRecord (sing @d))-    instance SingI d =>-             SingI (TyCon1 (MkRecord (d :: a)) :: (~>) Bool (Record a)) where-      sing-        = (singFun1 @(TyCon1 (MkRecord (d :: a)))) (SMkRecord (sing @d))
+ tests/compile-and-dump/Singletons/Records.ghc88.template view
@@ -0,0 +1,73 @@+Singletons/Records.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Record a = MkRecord {field1 :: a, field2 :: Bool} |]+  ======>+    data Record a = MkRecord {field1 :: a, field2 :: Bool}+    type Field2Sym1 (a0123456789876543210 :: Record a0123456789876543210) =+        Field2 a0123456789876543210+    instance SuppressUnusedWarnings Field2Sym0 where+      suppressUnusedWarnings = snd (((,) Field2Sym0KindInference) ())+    data Field2Sym0 :: forall a0123456789876543210.+                       (~>) (Record a0123456789876543210) Bool+      where+        Field2Sym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply Field2Sym0 arg) (Field2Sym1 arg) =>+                                   Field2Sym0 a0123456789876543210+    type instance Apply Field2Sym0 a0123456789876543210 = Field2 a0123456789876543210+    type Field1Sym1 (a0123456789876543210 :: Record a0123456789876543210) =+        Field1 a0123456789876543210+    instance SuppressUnusedWarnings Field1Sym0 where+      suppressUnusedWarnings = snd (((,) Field1Sym0KindInference) ())+    data Field1Sym0 :: forall a0123456789876543210.+                       (~>) (Record a0123456789876543210) a0123456789876543210+      where+        Field1Sym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply Field1Sym0 arg) (Field1Sym1 arg) =>+                                   Field1Sym0 a0123456789876543210+    type instance Apply Field1Sym0 a0123456789876543210 = Field1 a0123456789876543210+    type family Field2 (a :: Record a) :: Bool where+      Field2 (MkRecord _ field) = field+    type family Field1 (a :: Record a) :: a where+      Field1 (MkRecord field _) = field+    type MkRecordSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: Bool) =+        MkRecord t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkRecordSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkRecordSym1KindInference) ())+    data MkRecordSym1 (t0123456789876543210 :: a0123456789876543210) :: (~>) Bool (Record a0123456789876543210)+      where+        MkRecordSym1KindInference :: forall t0123456789876543210+                                            t0123456789876543210+                                            arg. SameKind (Apply (MkRecordSym1 t0123456789876543210) arg) (MkRecordSym2 t0123456789876543210 arg) =>+                                     MkRecordSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (MkRecordSym1 t0123456789876543210) t0123456789876543210 = MkRecord t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings MkRecordSym0 where+      suppressUnusedWarnings = snd (((,) MkRecordSym0KindInference) ())+    data MkRecordSym0 :: forall a0123456789876543210.+                         (~>) a0123456789876543210 ((~>) Bool (Record a0123456789876543210))+      where+        MkRecordSym0KindInference :: forall t0123456789876543210+                                            arg. SameKind (Apply MkRecordSym0 arg) (MkRecordSym1 arg) =>+                                     MkRecordSym0 t0123456789876543210+    type instance Apply MkRecordSym0 t0123456789876543210 = MkRecordSym1 t0123456789876543210+    data SRecord :: forall a. Record a -> GHC.Types.Type+      where+        SMkRecord :: forall a (n :: a) (n :: Bool).+                     {sField1 :: (Sing (n :: a)), sField2 :: (Sing (n :: Bool))}+                     -> SRecord (MkRecord n n)+    type instance Sing @(Record a) = SRecord+    instance SingKind a => SingKind (Record a) where+      type Demote (Record a) = Record (Demote a)+      fromSing (SMkRecord b b) = (MkRecord (fromSing b)) (fromSing b)+      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) }+    instance (SingI n, SingI n) =>+             SingI (MkRecord (n :: a) (n :: Bool)) where+      sing = (SMkRecord sing) sing+    instance SingI (MkRecordSym0 :: (~>) a ((~>) Bool (Record a))) where+      sing = (singFun2 @MkRecordSym0) SMkRecord+    instance SingI d =>+             SingI (MkRecordSym1 (d :: a) :: (~>) Bool (Record a)) where+      sing = (singFun1 @(MkRecordSym1 (d :: a))) (SMkRecord (sing @d))
− tests/compile-and-dump/Singletons/ReturnFunc.ghc86.template 
@@ -1,98 +0,0 @@-Singletons/ReturnFunc.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| returnFunc :: Nat -> Nat -> Nat-          returnFunc _ = Succ-          id :: a -> a-          id x = x-          idFoo :: c -> a -> a-          idFoo _ = id |]-  ======>-    returnFunc :: Nat -> Nat -> Nat-    returnFunc _ = Succ-    id :: a -> a-    id x = x-    idFoo :: c -> a -> a-    idFoo _ = id-    type IdSym1 (a0123456789876543210 :: a0123456789876543210) =-        Id a0123456789876543210-    instance SuppressUnusedWarnings IdSym0 where-      suppressUnusedWarnings = snd (((,) IdSym0KindInference) ())-    data IdSym0 :: forall a0123456789876543210.-                   (~>) a0123456789876543210 a0123456789876543210-      where-        IdSym0KindInference :: forall a0123456789876543210-                                      arg. SameKind (Apply IdSym0 arg) (IdSym1 arg) =>-                               IdSym0 a0123456789876543210-    type instance Apply IdSym0 a0123456789876543210 = Id a0123456789876543210-    type IdFooSym2 (a0123456789876543210 :: c0123456789876543210) (a0123456789876543210 :: a0123456789876543210) =-        IdFoo a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (IdFooSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) IdFooSym1KindInference) ())-    data IdFooSym1 (a0123456789876543210 :: c0123456789876543210) :: forall a0123456789876543210.-                                                                     (~>) a0123456789876543210 a0123456789876543210-      where-        IdFooSym1KindInference :: forall a0123456789876543210-                                         a0123456789876543210-                                         arg. SameKind (Apply (IdFooSym1 a0123456789876543210) arg) (IdFooSym2 a0123456789876543210 arg) =>-                                  IdFooSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (IdFooSym1 a0123456789876543210) a0123456789876543210 = IdFoo a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings IdFooSym0 where-      suppressUnusedWarnings = snd (((,) IdFooSym0KindInference) ())-    data IdFooSym0 :: forall a0123456789876543210 c0123456789876543210.-                      (~>) c0123456789876543210 ((~>) a0123456789876543210 a0123456789876543210)-      where-        IdFooSym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply IdFooSym0 arg) (IdFooSym1 arg) =>-                                  IdFooSym0 a0123456789876543210-    type instance Apply IdFooSym0 a0123456789876543210 = IdFooSym1 a0123456789876543210-    type ReturnFuncSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        ReturnFunc a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ReturnFuncSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ReturnFuncSym1KindInference) ())-    data ReturnFuncSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Nat-      where-        ReturnFuncSym1KindInference :: forall a0123456789876543210-                                              a0123456789876543210-                                              arg. SameKind (Apply (ReturnFuncSym1 a0123456789876543210) arg) (ReturnFuncSym2 a0123456789876543210 arg) =>-                                       ReturnFuncSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (ReturnFuncSym1 a0123456789876543210) a0123456789876543210 = ReturnFunc a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ReturnFuncSym0 where-      suppressUnusedWarnings = snd (((,) ReturnFuncSym0KindInference) ())-    data ReturnFuncSym0 :: (~>) Nat ((~>) Nat Nat)-      where-        ReturnFuncSym0KindInference :: forall a0123456789876543210-                                              arg. SameKind (Apply ReturnFuncSym0 arg) (ReturnFuncSym1 arg) =>-                                       ReturnFuncSym0 a0123456789876543210-    type instance Apply ReturnFuncSym0 a0123456789876543210 = ReturnFuncSym1 a0123456789876543210-    type family Id (a :: a) :: a where-      Id x = x-    type family IdFoo (a :: c) (a :: a) :: a where-      IdFoo _ a_0123456789876543210 = Apply IdSym0 a_0123456789876543210-    type family ReturnFunc (a :: Nat) (a :: Nat) :: Nat where-      ReturnFunc _ a_0123456789876543210 = Apply SuccSym0 a_0123456789876543210-    sId :: forall a (t :: a). Sing t -> Sing (Apply IdSym0 t :: a)-    sIdFoo ::-      forall c a (t :: c) (t :: a).-      Sing t -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t :: a)-    sReturnFunc ::-      forall (t :: Nat) (t :: Nat).-      Sing t -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t :: Nat)-    sId (sX :: Sing x) = sX-    sIdFoo _ (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing ((singFun1 @IdSym0) sId)) sA_0123456789876543210-    sReturnFunc-      _-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing ((singFun1 @SuccSym0) SSucc)) sA_0123456789876543210-    instance SingI (IdSym0 :: (~>) a a) where-      sing = (singFun1 @IdSym0) sId-    instance SingI (IdFooSym0 :: (~>) c ((~>) a a)) where-      sing = (singFun2 @IdFooSym0) sIdFoo-    instance SingI d => SingI (IdFooSym1 (d :: c) :: (~>) a a) where-      sing = (singFun1 @(IdFooSym1 (d :: c))) (sIdFoo (sing @d))-    instance SingI (ReturnFuncSym0 :: (~>) Nat ((~>) Nat Nat)) where-      sing = (singFun2 @ReturnFuncSym0) sReturnFunc-    instance SingI d =>-             SingI (ReturnFuncSym1 (d :: Nat) :: (~>) Nat Nat) where-      sing-        = (singFun1 @(ReturnFuncSym1 (d :: Nat))) (sReturnFunc (sing @d))
+ tests/compile-and-dump/Singletons/ReturnFunc.ghc88.template view
@@ -0,0 +1,98 @@+Singletons/ReturnFunc.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| returnFunc :: Nat -> Nat -> Nat+          returnFunc _ = Succ+          id :: a -> a+          id x = x+          idFoo :: c -> a -> a+          idFoo _ = id |]+  ======>+    returnFunc :: Nat -> Nat -> Nat+    returnFunc _ = Succ+    id :: a -> a+    id x = x+    idFoo :: c -> a -> a+    idFoo _ = id+    type IdFooSym2 (a0123456789876543210 :: c0123456789876543210) (a0123456789876543210 :: a0123456789876543210) =+        IdFoo a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (IdFooSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) IdFooSym1KindInference) ())+    data IdFooSym1 (a0123456789876543210 :: c0123456789876543210) :: forall a0123456789876543210.+                                                                     (~>) a0123456789876543210 a0123456789876543210+      where+        IdFooSym1KindInference :: forall a0123456789876543210+                                         a0123456789876543210+                                         arg. SameKind (Apply (IdFooSym1 a0123456789876543210) arg) (IdFooSym2 a0123456789876543210 arg) =>+                                  IdFooSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (IdFooSym1 a0123456789876543210) a0123456789876543210 = IdFoo a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings IdFooSym0 where+      suppressUnusedWarnings = snd (((,) IdFooSym0KindInference) ())+    data IdFooSym0 :: forall c0123456789876543210 a0123456789876543210.+                      (~>) c0123456789876543210 ((~>) a0123456789876543210 a0123456789876543210)+      where+        IdFooSym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply IdFooSym0 arg) (IdFooSym1 arg) =>+                                  IdFooSym0 a0123456789876543210+    type instance Apply IdFooSym0 a0123456789876543210 = IdFooSym1 a0123456789876543210+    type IdSym1 (a0123456789876543210 :: a0123456789876543210) =+        Id a0123456789876543210+    instance SuppressUnusedWarnings IdSym0 where+      suppressUnusedWarnings = snd (((,) IdSym0KindInference) ())+    data IdSym0 :: forall a0123456789876543210.+                   (~>) a0123456789876543210 a0123456789876543210+      where+        IdSym0KindInference :: forall a0123456789876543210+                                      arg. SameKind (Apply IdSym0 arg) (IdSym1 arg) =>+                               IdSym0 a0123456789876543210+    type instance Apply IdSym0 a0123456789876543210 = Id a0123456789876543210+    type ReturnFuncSym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        ReturnFunc a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ReturnFuncSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ReturnFuncSym1KindInference) ())+    data ReturnFuncSym1 (a0123456789876543210 :: Nat) :: (~>) Nat Nat+      where+        ReturnFuncSym1KindInference :: forall a0123456789876543210+                                              a0123456789876543210+                                              arg. SameKind (Apply (ReturnFuncSym1 a0123456789876543210) arg) (ReturnFuncSym2 a0123456789876543210 arg) =>+                                       ReturnFuncSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (ReturnFuncSym1 a0123456789876543210) a0123456789876543210 = ReturnFunc a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ReturnFuncSym0 where+      suppressUnusedWarnings = snd (((,) ReturnFuncSym0KindInference) ())+    data ReturnFuncSym0 :: (~>) Nat ((~>) Nat Nat)+      where+        ReturnFuncSym0KindInference :: forall a0123456789876543210+                                              arg. SameKind (Apply ReturnFuncSym0 arg) (ReturnFuncSym1 arg) =>+                                       ReturnFuncSym0 a0123456789876543210+    type instance Apply ReturnFuncSym0 a0123456789876543210 = ReturnFuncSym1 a0123456789876543210+    type family IdFoo (a :: c) (a :: a) :: a where+      IdFoo _ a_0123456789876543210 = Apply IdSym0 a_0123456789876543210+    type family Id (a :: a) :: a where+      Id x = x+    type family ReturnFunc (a :: Nat) (a :: Nat) :: Nat where+      ReturnFunc _ a_0123456789876543210 = Apply SuccSym0 a_0123456789876543210+    sIdFoo ::+      forall c a (t :: c) (t :: a).+      Sing t -> Sing t -> Sing (Apply (Apply IdFooSym0 t) t :: a)+    sId :: forall a (t :: a). Sing t -> Sing (Apply IdSym0 t :: a)+    sReturnFunc ::+      forall (t :: Nat) (t :: Nat).+      Sing t -> Sing t -> Sing (Apply (Apply ReturnFuncSym0 t) t :: Nat)+    sIdFoo _ (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing ((singFun1 @IdSym0) sId)) sA_0123456789876543210+    sId (sX :: Sing x) = sX+    sReturnFunc+      _+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing ((singFun1 @SuccSym0) SSucc)) sA_0123456789876543210+    instance SingI (IdFooSym0 :: (~>) c ((~>) a a)) where+      sing = (singFun2 @IdFooSym0) sIdFoo+    instance SingI d => SingI (IdFooSym1 (d :: c) :: (~>) a a) where+      sing = (singFun1 @(IdFooSym1 (d :: c))) (sIdFoo (sing @d))+    instance SingI (IdSym0 :: (~>) a a) where+      sing = (singFun1 @IdSym0) sId+    instance SingI (ReturnFuncSym0 :: (~>) Nat ((~>) Nat Nat)) where+      sing = (singFun2 @ReturnFuncSym0) sReturnFunc+    instance SingI d =>+             SingI (ReturnFuncSym1 (d :: Nat) :: (~>) Nat Nat) where+      sing+        = (singFun1 @(ReturnFuncSym1 (d :: Nat))) (sReturnFunc (sing @d))
− tests/compile-and-dump/Singletons/Sections.ghc86.template 
@@ -1,122 +0,0 @@-Singletons/Sections.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| (+) :: Nat -> Nat -> Nat-          Zero + m = m-          (Succ n) + m = Succ (n + m)-          foo1 :: [Nat]-          foo1 = map ((Succ Zero) +) [Zero, Succ Zero]-          foo2 :: [Nat]-          foo2 = map (+ (Succ Zero)) [Zero, Succ Zero]-          foo3 :: [Nat]-          foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero] |]-  ======>-    (+) :: Nat -> Nat -> Nat-    (+) Zero m = m-    (+) (Succ n) m = Succ (n + m)-    foo1 :: [Nat]-    foo1 = (map (Succ Zero +)) [Zero, Succ Zero]-    foo2 :: [Nat]-    foo2 = (map (+ Succ Zero)) [Zero, Succ Zero]-    foo3 :: [Nat]-    foo3 = ((zipWith (+)) [Succ Zero, Succ Zero]) [Zero, Succ Zero]-    type family Lambda_0123456789876543210 t where-      Lambda_0123456789876543210 lhs_0123456789876543210 = Apply (Apply (+@#@$) lhs_0123456789876543210) (Apply SuccSym0 ZeroSym0)-    type Lambda_0123456789876543210Sym1 t0123456789876543210 =-        Lambda_0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 t0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall t0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 t0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210-    type (+@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        (+) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((+@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:+@#@$$###)) ())-    data (+@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat-      where-        (:+@#@$$###) :: forall a0123456789876543210-                               a0123456789876543210-                               arg. SameKind (Apply ((+@#@$$) a0123456789876543210) arg) ((+@#@$$$) a0123456789876543210 arg) =>-                        (+@#@$$) a0123456789876543210 a0123456789876543210-    type instance Apply ((+@#@$$) a0123456789876543210) a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (+@#@$) where-      suppressUnusedWarnings = snd (((,) (:+@#@$###)) ())-    data (+@#@$) :: (~>) Nat ((~>) Nat Nat)-      where-        (:+@#@$###) :: forall a0123456789876543210-                              arg. SameKind (Apply (+@#@$) arg) ((+@#@$$) arg) =>-                       (+@#@$) a0123456789876543210-    type instance Apply (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210-    type Foo1Sym0 = Foo1-    type Foo2Sym0 = Foo2-    type Foo3Sym0 = Foo3-    type family (+) (a :: Nat) (a :: Nat) :: Nat where-      (+)  'Zero m = m-      (+) ( 'Succ n) m = Apply SuccSym0 (Apply (Apply (+@#@$) n) m)-    type family Foo1 :: [Nat] where-      Foo1 = Apply (Apply MapSym0 (Apply (+@#@$) (Apply SuccSym0 ZeroSym0))) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) '[]))-    type family Foo2 :: [Nat] where-      Foo2 = Apply (Apply MapSym0 Lambda_0123456789876543210Sym0) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) '[]))-    type family Foo3 :: [Nat] where-      Foo3 = Apply (Apply (Apply ZipWithSym0 (+@#@$)) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) '[]))) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) '[]))-    (%+) ::-      forall (t :: Nat) (t :: Nat).-      Sing t -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat)-    sFoo1 :: Sing (Foo1Sym0 :: [Nat])-    sFoo2 :: Sing (Foo2Sym0 :: [Nat])-    sFoo3 :: Sing (Foo3Sym0 :: [Nat])-    (%+) SZero (sM :: Sing m) = sM-    (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)-      = (applySing ((singFun1 @SuccSym0) SSucc))-          ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sN)) sM)-    sFoo1-      = (applySing-           ((applySing ((singFun2 @MapSym0) sMap))-              ((applySing ((singFun2 @(+@#@$)) (%+)))-                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-                SNil))-    sFoo2-      = (applySing-           ((applySing ((singFun2 @MapSym0) sMap))-              ((singFun1 @Lambda_0123456789876543210Sym0)-                 (\ sLhs_0123456789876543210-                    -> case sLhs_0123456789876543210 of {-                         (_ :: Sing lhs_0123456789876543210)-                           -> (applySing-                                 ((applySing ((singFun2 @(+@#@$)) (%+))) sLhs_0123456789876543210))-                                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero) }))))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-                SNil))-    sFoo3-      = (applySing-           ((applySing-               ((applySing ((singFun3 @ZipWithSym0) sZipWith))-                  ((singFun2 @(+@#@$)) (%+))))-              ((applySing-                  ((applySing ((singFun2 @(:@#@$)) SCons))-                     ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-                 ((applySing-                     ((applySing ((singFun2 @(:@#@$)) SCons))-                        ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-                    SNil))))-          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))-             ((applySing-                 ((applySing ((singFun2 @(:@#@$)) SCons))-                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))-                SNil))-    instance SingI ((+@#@$) :: (~>) Nat ((~>) Nat Nat)) where-      sing = (singFun2 @(+@#@$)) (%+)-    instance SingI d =>-             SingI ((+@#@$$) (d :: Nat) :: (~>) Nat Nat) where-      sing = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) (sing @d))
+ tests/compile-and-dump/Singletons/Sections.ghc88.template view
@@ -0,0 +1,122 @@+Singletons/Sections.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| (+) :: Nat -> Nat -> Nat+          Zero + m = m+          (Succ n) + m = Succ (n + m)+          foo1 :: [Nat]+          foo1 = map ((Succ Zero) +) [Zero, Succ Zero]+          foo2 :: [Nat]+          foo2 = map (+ (Succ Zero)) [Zero, Succ Zero]+          foo3 :: [Nat]+          foo3 = zipWith (+) [Succ Zero, Succ Zero] [Zero, Succ Zero] |]+  ======>+    (+) :: Nat -> Nat -> Nat+    (+) Zero m = m+    (+) (Succ n) m = Succ (n + m)+    foo1 :: [Nat]+    foo1 = (map (Succ Zero +)) [Zero, Succ Zero]+    foo2 :: [Nat]+    foo2 = (map (+ Succ Zero)) [Zero, Succ Zero]+    foo3 :: [Nat]+    foo3 = ((zipWith (+)) [Succ Zero, Succ Zero]) [Zero, Succ Zero]+    type family Lambda_0123456789876543210 t where+      Lambda_0123456789876543210 lhs_0123456789876543210 = Apply (Apply (+@#@$) lhs_0123456789876543210) (Apply SuccSym0 ZeroSym0)+    type Lambda_0123456789876543210Sym1 t0123456789876543210 =+        Lambda_0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 t0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall t0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 t0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 t0123456789876543210 = Lambda_0123456789876543210 t0123456789876543210+    type Foo3Sym0 = Foo3+    type Foo2Sym0 = Foo2+    type Foo1Sym0 = Foo1+    type (+@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        (+) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((+@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:+@#@$$###)) ())+    data (+@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat+      where+        (:+@#@$$###) :: forall a0123456789876543210+                               a0123456789876543210+                               arg. SameKind (Apply ((+@#@$$) a0123456789876543210) arg) ((+@#@$$$) a0123456789876543210 arg) =>+                        (+@#@$$) a0123456789876543210 a0123456789876543210+    type instance Apply ((+@#@$$) a0123456789876543210) a0123456789876543210 = (+) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (+@#@$) where+      suppressUnusedWarnings = snd (((,) (:+@#@$###)) ())+    data (+@#@$) :: (~>) Nat ((~>) Nat Nat)+      where+        (:+@#@$###) :: forall a0123456789876543210+                              arg. SameKind (Apply (+@#@$) arg) ((+@#@$$) arg) =>+                       (+@#@$) a0123456789876543210+    type instance Apply (+@#@$) a0123456789876543210 = (+@#@$$) a0123456789876543210+    type family Foo3 :: [Nat] where+      Foo3 = Apply (Apply (Apply ZipWithSym0 (+@#@$)) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) '[]))) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) '[]))+    type family Foo2 :: [Nat] where+      Foo2 = Apply (Apply MapSym0 Lambda_0123456789876543210Sym0) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) '[]))+    type family Foo1 :: [Nat] where+      Foo1 = Apply (Apply MapSym0 (Apply (+@#@$) (Apply SuccSym0 ZeroSym0))) (Apply (Apply (:@#@$) ZeroSym0) (Apply (Apply (:@#@$) (Apply SuccSym0 ZeroSym0)) '[]))+    type family (+) (a :: Nat) (a :: Nat) :: Nat where+      (+) 'Zero m = m+      (+) ('Succ n) m = Apply SuccSym0 (Apply (Apply (+@#@$) n) m)+    sFoo3 :: Sing (Foo3Sym0 :: [Nat])+    sFoo2 :: Sing (Foo2Sym0 :: [Nat])+    sFoo1 :: Sing (Foo1Sym0 :: [Nat])+    (%+) ::+      forall (t :: Nat) (t :: Nat).+      Sing t -> Sing t -> Sing (Apply (Apply (+@#@$) t) t :: Nat)+    sFoo3+      = (applySing+           ((applySing+               ((applySing ((singFun3 @ZipWithSym0) sZipWith))+                  ((singFun2 @(+@#@$)) (%+))))+              ((applySing+                  ((applySing ((singFun2 @(:@#@$)) SCons))+                     ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+                 ((applySing+                     ((applySing ((singFun2 @(:@#@$)) SCons))+                        ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+                    SNil))))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+                SNil))+    sFoo2+      = (applySing+           ((applySing ((singFun2 @MapSym0) sMap))+              ((singFun1 @Lambda_0123456789876543210Sym0)+                 (\ sLhs_0123456789876543210+                    -> case sLhs_0123456789876543210 of {+                         (_ :: Sing lhs_0123456789876543210)+                           -> (applySing+                                 ((applySing ((singFun2 @(+@#@$)) (%+))) sLhs_0123456789876543210))+                                ((applySing ((singFun1 @SuccSym0) SSucc)) SZero) }))))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+                SNil))+    sFoo1+      = (applySing+           ((applySing ((singFun2 @MapSym0) sMap))+              ((applySing ((singFun2 @(+@#@$)) (%+)))+                 ((applySing ((singFun1 @SuccSym0) SSucc)) SZero))))+          ((applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SZero))+             ((applySing+                 ((applySing ((singFun2 @(:@#@$)) SCons))+                    ((applySing ((singFun1 @SuccSym0) SSucc)) SZero)))+                SNil))+    (%+) SZero (sM :: Sing m) = sM+    (%+) (SSucc (sN :: Sing n)) (sM :: Sing m)+      = (applySing ((singFun1 @SuccSym0) SSucc))+          ((applySing ((applySing ((singFun2 @(+@#@$)) (%+))) sN)) sM)+    instance SingI ((+@#@$) :: (~>) Nat ((~>) Nat Nat)) where+      sing = (singFun2 @(+@#@$)) (%+)+    instance SingI d =>+             SingI ((+@#@$$) (d :: Nat) :: (~>) Nat Nat) where+      sing = (singFun1 @((+@#@$$) (d :: Nat))) ((%+) (sing @d))
− tests/compile-and-dump/Singletons/ShowDeriving.ghc86.template 
@@ -1,582 +0,0 @@-Singletons/ShowDeriving.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| infixl 5 `MkFoo2b`, :*:, :&:-          -          data Foo1-            = MkFoo1-            deriving Show-          data Foo2 a-            = MkFoo2a a a | a `MkFoo2b` a | (:*:) a a | a :&: a-            deriving Show-          data Foo3-            = MkFoo3 {getFoo3a :: Bool, *** :: Bool}-            deriving Show |]-  ======>-    data Foo1-      = MkFoo1-      deriving Show-    infixl 5 `MkFoo2b`-    infixl 5 :*:-    infixl 5 :&:-    data Foo2 a-      = MkFoo2a a a | a `MkFoo2b` a | (:*:) a a | a :&: a-      deriving Show-    data Foo3-      = MkFoo3 {getFoo3a :: Bool, *** :: Bool}-      deriving Show-    type GetFoo3aSym1 (a0123456789876543210 :: Foo3) =-        GetFoo3a a0123456789876543210-    instance SuppressUnusedWarnings GetFoo3aSym0 where-      suppressUnusedWarnings = snd (((,) GetFoo3aSym0KindInference) ())-    data GetFoo3aSym0 :: (~>) Foo3 Bool-      where-        GetFoo3aSym0KindInference :: forall a0123456789876543210-                                            arg. SameKind (Apply GetFoo3aSym0 arg) (GetFoo3aSym1 arg) =>-                                     GetFoo3aSym0 a0123456789876543210-    type instance Apply GetFoo3aSym0 a0123456789876543210 = GetFoo3a a0123456789876543210-    type (***@#@$$) (a0123456789876543210 :: Foo3) =-        (***) a0123456789876543210-    instance SuppressUnusedWarnings (***@#@$) where-      suppressUnusedWarnings = snd (((,) (:***@#@$###)) ())-    data (***@#@$) :: (~>) Foo3 Bool-      where-        (:***@#@$###) :: forall a0123456789876543210-                                arg. SameKind (Apply (***@#@$) arg) ((***@#@$$) arg) =>-                         (***@#@$) a0123456789876543210-    type instance Apply (***@#@$) a0123456789876543210 = (***) a0123456789876543210-    type family GetFoo3a (a :: Foo3) :: Bool where-      GetFoo3a (MkFoo3 field _) = field-    type family (***) (a :: Foo3) :: Bool where-      (***) (MkFoo3 _ field) = field-    type MkFoo1Sym0 = MkFoo1-    type MkFoo2aSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: a0123456789876543210) =-        MkFoo2a t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkFoo2aSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkFoo2aSym1KindInference) ())-    data MkFoo2aSym1 (t0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 (Foo2 a0123456789876543210)-      where-        MkFoo2aSym1KindInference :: forall t0123456789876543210-                                           t0123456789876543210-                                           arg. SameKind (Apply (MkFoo2aSym1 t0123456789876543210) arg) (MkFoo2aSym2 t0123456789876543210 arg) =>-                                    MkFoo2aSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (MkFoo2aSym1 t0123456789876543210) t0123456789876543210 = MkFoo2a t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings MkFoo2aSym0 where-      suppressUnusedWarnings = snd (((,) MkFoo2aSym0KindInference) ())-    data MkFoo2aSym0 :: forall a0123456789876543210.-                        (~>) a0123456789876543210 ((~>) a0123456789876543210 (Foo2 a0123456789876543210))-      where-        MkFoo2aSym0KindInference :: forall t0123456789876543210-                                           arg. SameKind (Apply MkFoo2aSym0 arg) (MkFoo2aSym1 arg) =>-                                    MkFoo2aSym0 t0123456789876543210-    type instance Apply MkFoo2aSym0 t0123456789876543210 = MkFoo2aSym1 t0123456789876543210-    type MkFoo2bSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: a0123456789876543210) =-        MkFoo2b t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkFoo2bSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkFoo2bSym1KindInference) ())-    data MkFoo2bSym1 (t0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 (Foo2 a0123456789876543210)-      where-        MkFoo2bSym1KindInference :: forall t0123456789876543210-                                           t0123456789876543210-                                           arg. SameKind (Apply (MkFoo2bSym1 t0123456789876543210) arg) (MkFoo2bSym2 t0123456789876543210 arg) =>-                                    MkFoo2bSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (MkFoo2bSym1 t0123456789876543210) t0123456789876543210 = MkFoo2b t0123456789876543210 t0123456789876543210-    infixl 5 `MkFoo2bSym1`-    instance SuppressUnusedWarnings MkFoo2bSym0 where-      suppressUnusedWarnings = snd (((,) MkFoo2bSym0KindInference) ())-    data MkFoo2bSym0 :: forall a0123456789876543210.-                        (~>) a0123456789876543210 ((~>) a0123456789876543210 (Foo2 a0123456789876543210))-      where-        MkFoo2bSym0KindInference :: forall t0123456789876543210-                                           arg. SameKind (Apply MkFoo2bSym0 arg) (MkFoo2bSym1 arg) =>-                                    MkFoo2bSym0 t0123456789876543210-    type instance Apply MkFoo2bSym0 t0123456789876543210 = MkFoo2bSym1 t0123456789876543210-    infixl 5 `MkFoo2bSym0`-    type (:*:@#@$$$) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: a0123456789876543210) =-        (:*:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:*:@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())-    data (:*:@#@$$) (t0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 (Foo2 a0123456789876543210)-      where-        (::*:@#@$$###) :: forall t0123456789876543210-                                 t0123456789876543210-                                 arg. SameKind (Apply ((:*:@#@$$) t0123456789876543210) arg) ((:*:@#@$$$) t0123456789876543210 arg) =>-                          (:*:@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:*:@#@$$) t0123456789876543210) t0123456789876543210 = (:*:) t0123456789876543210 t0123456789876543210-    infixl 5 :*:@#@$$-    instance SuppressUnusedWarnings (:*:@#@$) where-      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())-    data (:*:@#@$) :: forall a0123456789876543210.-                      (~>) a0123456789876543210 ((~>) a0123456789876543210 (Foo2 a0123456789876543210))-      where-        (::*:@#@$###) :: forall t0123456789876543210-                                arg. SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>-                         (:*:@#@$) t0123456789876543210-    type instance Apply (:*:@#@$) t0123456789876543210 = (:*:@#@$$) t0123456789876543210-    infixl 5 :*:@#@$-    type (:&:@#@$$$) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: a0123456789876543210) =-        (:&:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:&:@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::&:@#@$$###)) ())-    data (:&:@#@$$) (t0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 (Foo2 a0123456789876543210)-      where-        (::&:@#@$$###) :: forall t0123456789876543210-                                 t0123456789876543210-                                 arg. SameKind (Apply ((:&:@#@$$) t0123456789876543210) arg) ((:&:@#@$$$) t0123456789876543210 arg) =>-                          (:&:@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:&:@#@$$) t0123456789876543210) t0123456789876543210 = (:&:) t0123456789876543210 t0123456789876543210-    infixl 5 :&:@#@$$-    instance SuppressUnusedWarnings (:&:@#@$) where-      suppressUnusedWarnings = snd (((,) (::&:@#@$###)) ())-    data (:&:@#@$) :: forall a0123456789876543210.-                      (~>) a0123456789876543210 ((~>) a0123456789876543210 (Foo2 a0123456789876543210))-      where-        (::&:@#@$###) :: forall t0123456789876543210-                                arg. SameKind (Apply (:&:@#@$) arg) ((:&:@#@$$) arg) =>-                         (:&:@#@$) t0123456789876543210-    type instance Apply (:&:@#@$) t0123456789876543210 = (:&:@#@$$) t0123456789876543210-    infixl 5 :&:@#@$-    type MkFoo3Sym2 (t0123456789876543210 :: Bool) (t0123456789876543210 :: Bool) =-        MkFoo3 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkFoo3Sym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkFoo3Sym1KindInference) ())-    data MkFoo3Sym1 (t0123456789876543210 :: Bool) :: (~>) Bool Foo3-      where-        MkFoo3Sym1KindInference :: forall t0123456789876543210-                                          t0123456789876543210-                                          arg. SameKind (Apply (MkFoo3Sym1 t0123456789876543210) arg) (MkFoo3Sym2 t0123456789876543210 arg) =>-                                   MkFoo3Sym1 t0123456789876543210 t0123456789876543210-    type instance Apply (MkFoo3Sym1 t0123456789876543210) t0123456789876543210 = MkFoo3 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings MkFoo3Sym0 where-      suppressUnusedWarnings = snd (((,) MkFoo3Sym0KindInference) ())-    data MkFoo3Sym0 :: (~>) Bool ((~>) Bool Foo3)-      where-        MkFoo3Sym0KindInference :: forall t0123456789876543210-                                          arg. SameKind (Apply MkFoo3Sym0 arg) (MkFoo3Sym1 arg) =>-                                   MkFoo3Sym0 t0123456789876543210-    type instance Apply MkFoo3Sym0 t0123456789876543210 = MkFoo3Sym1 t0123456789876543210-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Foo1) (a :: Symbol) :: Symbol where-      ShowsPrec_0123456789876543210 _ MkFoo1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "MkFoo1") a_0123456789876543210-    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo1) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo1) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo1 ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo1 ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow Foo1 where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo2 a0123456789876543210) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo2 a0123456789876543210) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.-                                                                                      (~>) (Foo2 a0123456789876543210) ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.-                                              (~>) GHC.Types.Nat ((~>) (Foo2 a0123456789876543210) ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow (Foo2 a) where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo3) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo3) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo3 ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo3 ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow Foo3 where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    infixl 5 `SMkFoo2b`-    infixl 5 :%*:-    infixl 5 :%&:-    data instance Sing :: Foo1 -> GHC.Types.Type-      where SMkFoo1 :: Sing MkFoo1-    type SFoo1 = (Sing :: Foo1 -> GHC.Types.Type)-    instance SingKind Foo1 where-      type Demote Foo1 = Foo1-      fromSing SMkFoo1 = MkFoo1-      toSing MkFoo1 = SomeSing SMkFoo1-    data instance Sing :: Foo2 a -> GHC.Types.Type-      where-        SMkFoo2a :: forall a (n :: a) (n :: a).-                    (Sing (n :: a)) -> (Sing (n :: a)) -> Sing (MkFoo2a n n)-        SMkFoo2b :: forall a (n :: a) (n :: a).-                    (Sing (n :: a)) -> (Sing (n :: a)) -> Sing (MkFoo2b n n)-        (:%*:) :: forall a (n :: a) (n :: a).-                  (Sing (n :: a)) -> (Sing (n :: a)) -> Sing ((:*:) n n)-        (:%&:) :: forall a (n :: a) (n :: a).-                  (Sing (n :: a)) -> (Sing (n :: a)) -> Sing ((:&:) n n)-    type SFoo2 = (Sing :: Foo2 a -> GHC.Types.Type)-    instance SingKind a => SingKind (Foo2 a) where-      type Demote (Foo2 a) = Foo2 (Demote a)-      fromSing (SMkFoo2a b b) = (MkFoo2a (fromSing b)) (fromSing b)-      fromSing (SMkFoo2b b b) = (MkFoo2b (fromSing b)) (fromSing b)-      fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b)-      fromSing ((:%&:) b b) = ((:&:) (fromSing b)) (fromSing b)-      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) }-      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) }-      toSing ((:*:) (b :: Demote a) (b :: Demote a))-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of {-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) }-      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 instance Sing :: Foo3 -> GHC.Types.Type-      where-        SMkFoo3 :: forall (n :: Bool) (n :: Bool).-                   {sGetFoo3a :: (Sing (n :: Bool)), %*** :: (Sing (n :: Bool))}-                   -> Sing (MkFoo3 n n)-    type SFoo3 = (Sing :: Foo3 -> GHC.Types.Type)-    instance SingKind Foo3 where-      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) }-    instance SShow Foo1 where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Foo1) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo1 ((~>) Symbol Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        _-        SMkFoo1-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "MkFoo1")))-            sA_0123456789876543210-    instance SShow a => SShow (Foo2 a) where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Foo2 a) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Foo2 a) ((~>) Symbol Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SMkFoo2a (sArg_0123456789876543210 :: Sing arg_0123456789876543210)-                  (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "MkFoo2a "))))-                   ((applySing-                       ((applySing ((singFun3 @(.@#@$)) (%.)))-                          ((applySing-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                 (sFromInteger (sing :: Sing 11))))-                             sArg_0123456789876543210)))-                      ((applySing-                          ((applySing ((singFun3 @(.@#@$)) (%.)))-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))-                         ((applySing-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                (sFromInteger (sing :: Sing 11))))-                            sArg_0123456789876543210))))))-            sA_0123456789876543210-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SMkFoo2b (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)-                  (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 5)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing-                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                              (sFromInteger (sing :: Sing 6))))-                          sArgL_0123456789876543210)))-                   ((applySing-                       ((applySing ((singFun3 @(.@#@$)) (%.)))-                          ((applySing ((singFun2 @ShowStringSym0) sShowString))-                             (sing :: Sing " `MkFoo2b` "))))-                      ((applySing-                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                             (sFromInteger (sing :: Sing 6))))-                         sArgR_0123456789876543210)))))-            sA_0123456789876543210-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        ((:%*:) (sArg_0123456789876543210 :: Sing arg_0123456789876543210)-                (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "(:*:) "))))-                   ((applySing-                       ((applySing ((singFun3 @(.@#@$)) (%.)))-                          ((applySing-                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                 (sFromInteger (sing :: Sing 11))))-                             sArg_0123456789876543210)))-                      ((applySing-                          ((applySing ((singFun3 @(.@#@$)) (%.)))-                             ((singFun1 @ShowSpaceSym0) sShowSpace)))-                         ((applySing-                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                (sFromInteger (sing :: Sing 11))))-                            sArg_0123456789876543210))))))-            sA_0123456789876543210-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        ((:%&:) (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)-                (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 5)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing-                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                              (sFromInteger (sing :: Sing 6))))-                          sArgL_0123456789876543210)))-                   ((applySing-                       ((applySing ((singFun3 @(.@#@$)) (%.)))-                          ((applySing ((singFun2 @ShowStringSym0) sShowString))-                             (sing :: Sing " :&: "))))-                      ((applySing-                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                             (sFromInteger (sing :: Sing 6))))-                         sArgR_0123456789876543210)))))-            sA_0123456789876543210-    instance SShow Bool => SShow Foo3 where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Foo3) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo3 ((~>) Symbol Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SMkFoo3 (sArg_0123456789876543210 :: Sing arg_0123456789876543210)-                 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "MkFoo3 "))))-                   ((applySing-                       ((applySing ((singFun3 @(.@#@$)) (%.)))-                          ((applySing ((singFun2 @ShowCharSym0) sShowChar))-                             (sing :: Sing "{"))))-                      ((applySing-                          ((applySing ((singFun3 @(.@#@$)) (%.)))-                             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                                (sing :: Sing "getFoo3a = "))))-                         ((applySing-                             ((applySing ((singFun3 @(.@#@$)) (%.)))-                                ((applySing-                                    ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                       (sFromInteger (sing :: Sing 0))))-                                   sArg_0123456789876543210)))-                            ((applySing-                                ((applySing ((singFun3 @(.@#@$)) (%.)))-                                   ((singFun1 @ShowCommaSpaceSym0) sShowCommaSpace)))-                               ((applySing-                                   ((applySing ((singFun3 @(.@#@$)) (%.)))-                                      ((applySing ((singFun2 @ShowStringSym0) sShowString))-                                         (sing :: Sing "(***) = "))))-                                  ((applySing-                                      ((applySing ((singFun3 @(.@#@$)) (%.)))-                                         ((applySing-                                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                                                (sFromInteger (sing :: Sing 0))))-                                            sArg_0123456789876543210)))-                                     ((applySing ((singFun2 @ShowCharSym0) sShowChar))-                                        (sing :: Sing "}")))))))))))-            sA_0123456789876543210-    deriving instance Show (Sing (z :: Foo1))-    deriving instance Data.Singletons.ShowSing.ShowSing a =>-                      Show (Sing (z :: Foo2 a))-    deriving instance Data.Singletons.ShowSing.ShowSing Bool =>-                      Show (Sing (z :: Foo3))-    instance SingI MkFoo1 where-      sing = SMkFoo1-    instance (SingI n, SingI n) =>-             SingI (MkFoo2a (n :: a) (n :: a)) where-      sing = (SMkFoo2a sing) sing-    instance SingI (MkFoo2aSym0 :: (~>) a ((~>) a (Foo2 a))) where-      sing = (singFun2 @MkFoo2aSym0) SMkFoo2a-    instance SingI (TyCon2 MkFoo2a :: (~>) a ((~>) a (Foo2 a))) where-      sing = (singFun2 @(TyCon2 MkFoo2a)) SMkFoo2a-    instance SingI d =>-             SingI (MkFoo2aSym1 (d :: a) :: (~>) a (Foo2 a)) where-      sing = (singFun1 @(MkFoo2aSym1 (d :: a))) (SMkFoo2a (sing @d))-    instance SingI d =>-             SingI (TyCon1 (MkFoo2a (d :: a)) :: (~>) a (Foo2 a)) where-      sing = (singFun1 @(TyCon1 (MkFoo2a (d :: a)))) (SMkFoo2a (sing @d))-    instance (SingI n, SingI n) =>-             SingI (MkFoo2b (n :: a) (n :: a)) where-      sing = (SMkFoo2b sing) sing-    instance SingI (MkFoo2bSym0 :: (~>) a ((~>) a (Foo2 a))) where-      sing = (singFun2 @MkFoo2bSym0) SMkFoo2b-    instance SingI (TyCon2 MkFoo2b :: (~>) a ((~>) a (Foo2 a))) where-      sing = (singFun2 @(TyCon2 MkFoo2b)) SMkFoo2b-    instance SingI d =>-             SingI (MkFoo2bSym1 (d :: a) :: (~>) a (Foo2 a)) where-      sing = (singFun1 @(MkFoo2bSym1 (d :: a))) (SMkFoo2b (sing @d))-    instance SingI d =>-             SingI (TyCon1 (MkFoo2b (d :: a)) :: (~>) a (Foo2 a)) where-      sing = (singFun1 @(TyCon1 (MkFoo2b (d :: a)))) (SMkFoo2b (sing @d))-    instance (SingI n, SingI n) =>-             SingI ((:*:) (n :: a) (n :: a)) where-      sing = ((:%*:) sing) sing-    instance SingI ((:*:@#@$) :: (~>) a ((~>) a (Foo2 a))) where-      sing = (singFun2 @(:*:@#@$)) (:%*:)-    instance SingI (TyCon2 (:*:) :: (~>) a ((~>) a (Foo2 a))) where-      sing = (singFun2 @(TyCon2 (:*:))) (:%*:)-    instance SingI d =>-             SingI ((:*:@#@$$) (d :: a) :: (~>) a (Foo2 a)) where-      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ((:*:) (d :: a)) :: (~>) a (Foo2 a)) where-      sing = (singFun1 @(TyCon1 ((:*:) (d :: a)))) ((:%*:) (sing @d))-    instance (SingI n, SingI n) =>-             SingI ((:&:) (n :: a) (n :: a)) where-      sing = ((:%&:) sing) sing-    instance SingI ((:&:@#@$) :: (~>) a ((~>) a (Foo2 a))) where-      sing = (singFun2 @(:&:@#@$)) (:%&:)-    instance SingI (TyCon2 (:&:) :: (~>) a ((~>) a (Foo2 a))) where-      sing = (singFun2 @(TyCon2 (:&:))) (:%&:)-    instance SingI d =>-             SingI ((:&:@#@$$) (d :: a) :: (~>) a (Foo2 a)) where-      sing = (singFun1 @((:&:@#@$$) (d :: a))) ((:%&:) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ((:&:) (d :: a)) :: (~>) a (Foo2 a)) where-      sing = (singFun1 @(TyCon1 ((:&:) (d :: a)))) ((:%&:) (sing @d))-    instance (SingI n, SingI n) =>-             SingI (MkFoo3 (n :: Bool) (n :: Bool)) where-      sing = (SMkFoo3 sing) sing-    instance SingI (MkFoo3Sym0 :: (~>) Bool ((~>) Bool Foo3)) where-      sing = (singFun2 @MkFoo3Sym0) SMkFoo3-    instance SingI (TyCon2 MkFoo3 :: (~>) Bool ((~>) Bool Foo3)) where-      sing = (singFun2 @(TyCon2 MkFoo3)) SMkFoo3-    instance SingI d =>-             SingI (MkFoo3Sym1 (d :: Bool) :: (~>) Bool Foo3) where-      sing = (singFun1 @(MkFoo3Sym1 (d :: Bool))) (SMkFoo3 (sing @d))-    instance SingI d =>-             SingI (TyCon1 (MkFoo3 (d :: Bool)) :: (~>) Bool Foo3) where-      sing-        = (singFun1 @(TyCon1 (MkFoo3 (d :: Bool)))) (SMkFoo3 (sing @d))
+ tests/compile-and-dump/Singletons/ShowDeriving.ghc88.template view
@@ -0,0 +1,618 @@+Singletons/ShowDeriving.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| infixl 5 `MkFoo2b`, :*:, :&:+          +          data Foo1+            = MkFoo1+            deriving Show+          data Foo2 a+            = MkFoo2a a a | a `MkFoo2b` a | (:*:) a a | a :&: a+            deriving Show+          data Foo3+            = MkFoo3 {getFoo3a :: Bool, *** :: Bool}+            deriving Show |]+  ======>+    data Foo1+      = MkFoo1+      deriving Show+    infixl 5 `MkFoo2b`+    infixl 5 :*:+    infixl 5 :&:+    data Foo2 a+      = MkFoo2a a a | a `MkFoo2b` a | (:*:) a a | a :&: a+      deriving Show+    data Foo3+      = MkFoo3 {getFoo3a :: Bool, *** :: Bool}+      deriving Show+    type (***@#@$$) (a0123456789876543210 :: Foo3) =+        (***) a0123456789876543210+    instance SuppressUnusedWarnings (***@#@$) where+      suppressUnusedWarnings = snd (((,) (:***@#@$###)) ())+    data (***@#@$) :: (~>) Foo3 Bool+      where+        (:***@#@$###) :: forall a0123456789876543210+                                arg. SameKind (Apply (***@#@$) arg) ((***@#@$$) arg) =>+                         (***@#@$) a0123456789876543210+    type instance Apply (***@#@$) a0123456789876543210 = (***) a0123456789876543210+    type GetFoo3aSym1 (a0123456789876543210 :: Foo3) =+        GetFoo3a a0123456789876543210+    instance SuppressUnusedWarnings GetFoo3aSym0 where+      suppressUnusedWarnings = snd (((,) GetFoo3aSym0KindInference) ())+    data GetFoo3aSym0 :: (~>) Foo3 Bool+      where+        GetFoo3aSym0KindInference :: forall a0123456789876543210+                                            arg. SameKind (Apply GetFoo3aSym0 arg) (GetFoo3aSym1 arg) =>+                                     GetFoo3aSym0 a0123456789876543210+    type instance Apply GetFoo3aSym0 a0123456789876543210 = GetFoo3a a0123456789876543210+    type family (***) (a :: Foo3) :: Bool where+      (***) (MkFoo3 _ field) = field+    type family GetFoo3a (a :: Foo3) :: Bool where+      GetFoo3a (MkFoo3 field _) = field+    type MkFoo1Sym0 = MkFoo1+    type MkFoo2aSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: a0123456789876543210) =+        MkFoo2a t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkFoo2aSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkFoo2aSym1KindInference) ())+    data MkFoo2aSym1 (t0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 (Foo2 a0123456789876543210)+      where+        MkFoo2aSym1KindInference :: forall t0123456789876543210+                                           t0123456789876543210+                                           arg. SameKind (Apply (MkFoo2aSym1 t0123456789876543210) arg) (MkFoo2aSym2 t0123456789876543210 arg) =>+                                    MkFoo2aSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (MkFoo2aSym1 t0123456789876543210) t0123456789876543210 = MkFoo2a t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings MkFoo2aSym0 where+      suppressUnusedWarnings = snd (((,) MkFoo2aSym0KindInference) ())+    data MkFoo2aSym0 :: forall a0123456789876543210.+                        (~>) a0123456789876543210 ((~>) a0123456789876543210 (Foo2 a0123456789876543210))+      where+        MkFoo2aSym0KindInference :: forall t0123456789876543210+                                           arg. SameKind (Apply MkFoo2aSym0 arg) (MkFoo2aSym1 arg) =>+                                    MkFoo2aSym0 t0123456789876543210+    type instance Apply MkFoo2aSym0 t0123456789876543210 = MkFoo2aSym1 t0123456789876543210+    type MkFoo2bSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: a0123456789876543210) =+        MkFoo2b t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkFoo2bSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkFoo2bSym1KindInference) ())+    data MkFoo2bSym1 (t0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 (Foo2 a0123456789876543210)+      where+        MkFoo2bSym1KindInference :: forall t0123456789876543210+                                           t0123456789876543210+                                           arg. SameKind (Apply (MkFoo2bSym1 t0123456789876543210) arg) (MkFoo2bSym2 t0123456789876543210 arg) =>+                                    MkFoo2bSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (MkFoo2bSym1 t0123456789876543210) t0123456789876543210 = MkFoo2b t0123456789876543210 t0123456789876543210+    infixl 5 `MkFoo2bSym1`+    instance SuppressUnusedWarnings MkFoo2bSym0 where+      suppressUnusedWarnings = snd (((,) MkFoo2bSym0KindInference) ())+    data MkFoo2bSym0 :: forall a0123456789876543210.+                        (~>) a0123456789876543210 ((~>) a0123456789876543210 (Foo2 a0123456789876543210))+      where+        MkFoo2bSym0KindInference :: forall t0123456789876543210+                                           arg. SameKind (Apply MkFoo2bSym0 arg) (MkFoo2bSym1 arg) =>+                                    MkFoo2bSym0 t0123456789876543210+    type instance Apply MkFoo2bSym0 t0123456789876543210 = MkFoo2bSym1 t0123456789876543210+    infixl 5 `MkFoo2bSym0`+    type (:*:@#@$$$) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: a0123456789876543210) =+        (:*:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:*:@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())+    data (:*:@#@$$) (t0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 (Foo2 a0123456789876543210)+      where+        (::*:@#@$$###) :: forall t0123456789876543210+                                 t0123456789876543210+                                 arg. SameKind (Apply ((:*:@#@$$) t0123456789876543210) arg) ((:*:@#@$$$) t0123456789876543210 arg) =>+                          (:*:@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:*:@#@$$) t0123456789876543210) t0123456789876543210 = (:*:) t0123456789876543210 t0123456789876543210+    infixl 5 :*:@#@$$+    instance SuppressUnusedWarnings (:*:@#@$) where+      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())+    data (:*:@#@$) :: forall a0123456789876543210.+                      (~>) a0123456789876543210 ((~>) a0123456789876543210 (Foo2 a0123456789876543210))+      where+        (::*:@#@$###) :: forall t0123456789876543210+                                arg. SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>+                         (:*:@#@$) t0123456789876543210+    type instance Apply (:*:@#@$) t0123456789876543210 = (:*:@#@$$) t0123456789876543210+    infixl 5 :*:@#@$+    type (:&:@#@$$$) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: a0123456789876543210) =+        (:&:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:&:@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::&:@#@$$###)) ())+    data (:&:@#@$$) (t0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 (Foo2 a0123456789876543210)+      where+        (::&:@#@$$###) :: forall t0123456789876543210+                                 t0123456789876543210+                                 arg. SameKind (Apply ((:&:@#@$$) t0123456789876543210) arg) ((:&:@#@$$$) t0123456789876543210 arg) =>+                          (:&:@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:&:@#@$$) t0123456789876543210) t0123456789876543210 = (:&:) t0123456789876543210 t0123456789876543210+    infixl 5 :&:@#@$$+    instance SuppressUnusedWarnings (:&:@#@$) where+      suppressUnusedWarnings = snd (((,) (::&:@#@$###)) ())+    data (:&:@#@$) :: forall a0123456789876543210.+                      (~>) a0123456789876543210 ((~>) a0123456789876543210 (Foo2 a0123456789876543210))+      where+        (::&:@#@$###) :: forall t0123456789876543210+                                arg. SameKind (Apply (:&:@#@$) arg) ((:&:@#@$$) arg) =>+                         (:&:@#@$) t0123456789876543210+    type instance Apply (:&:@#@$) t0123456789876543210 = (:&:@#@$$) t0123456789876543210+    infixl 5 :&:@#@$+    type MkFoo3Sym2 (t0123456789876543210 :: Bool) (t0123456789876543210 :: Bool) =+        MkFoo3 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkFoo3Sym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkFoo3Sym1KindInference) ())+    data MkFoo3Sym1 (t0123456789876543210 :: Bool) :: (~>) Bool Foo3+      where+        MkFoo3Sym1KindInference :: forall t0123456789876543210+                                          t0123456789876543210+                                          arg. SameKind (Apply (MkFoo3Sym1 t0123456789876543210) arg) (MkFoo3Sym2 t0123456789876543210 arg) =>+                                   MkFoo3Sym1 t0123456789876543210 t0123456789876543210+    type instance Apply (MkFoo3Sym1 t0123456789876543210) t0123456789876543210 = MkFoo3 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings MkFoo3Sym0 where+      suppressUnusedWarnings = snd (((,) MkFoo3Sym0KindInference) ())+    data MkFoo3Sym0 :: (~>) Bool ((~>) Bool Foo3)+      where+        MkFoo3Sym0KindInference :: forall t0123456789876543210+                                          arg. SameKind (Apply MkFoo3Sym0 arg) (MkFoo3Sym1 arg) =>+                                   MkFoo3Sym0 t0123456789876543210+    type instance Apply MkFoo3Sym0 t0123456789876543210 = MkFoo3Sym1 t0123456789876543210+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: Foo1) (a :: Symbol) :: Symbol where+      ShowsPrec_0123456789876543210 _ MkFoo1 a_0123456789876543210 = Apply (Apply ShowStringSym0 "MkFoo1") a_0123456789876543210+    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo1) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo1) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo1 ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo1 ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow Foo1 where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo2 a0123456789876543210) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo2 a0123456789876543210) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.+                                                                                      (~>) (Foo2 a0123456789876543210) ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.+                                              (~>) GHC.Types.Nat ((~>) (Foo2 a0123456789876543210) ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow (Foo2 a) where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo3) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Foo3) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Foo3 ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Foo3 ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 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`+    data SFoo1 :: Foo1 -> GHC.Types.Type where SMkFoo1 :: SFoo1 MkFoo1+    type instance Sing @Foo1 = SFoo1+    instance SingKind Foo1 where+      type Demote Foo1 = Foo1+      fromSing SMkFoo1 = MkFoo1+      toSing MkFoo1 = SomeSing SMkFoo1+    data SFoo2 :: forall a. Foo2 a -> GHC.Types.Type+      where+        SMkFoo2a :: forall a (n :: a) (n :: a).+                    (Sing (n :: a)) -> (Sing (n :: a)) -> SFoo2 (MkFoo2a n n)+        SMkFoo2b :: forall a (n :: a) (n :: a).+                    (Sing (n :: a)) -> (Sing (n :: a)) -> SFoo2 (MkFoo2b n n)+        (:%*:) :: forall a (n :: a) (n :: a).+                  (Sing (n :: a)) -> (Sing (n :: a)) -> SFoo2 ((:*:) n n)+        (:%&:) :: forall a (n :: a) (n :: a).+                  (Sing (n :: a)) -> (Sing (n :: a)) -> SFoo2 ((:&:) n n)+    type instance Sing @(Foo2 a) = SFoo2+    instance SingKind a => SingKind (Foo2 a) where+      type Demote (Foo2 a) = Foo2 (Demote a)+      fromSing (SMkFoo2a b b) = (MkFoo2a (fromSing b)) (fromSing b)+      fromSing (SMkFoo2b b b) = (MkFoo2b (fromSing b)) (fromSing b)+      fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b)+      fromSing ((:%&:) b b) = ((:&:) (fromSing b)) (fromSing b)+      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) }+      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) }+      toSing ((:*:) (b :: Demote a) (b :: Demote a))+        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing a) of {+            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) }+      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 SFoo3 :: Foo3 -> GHC.Types.Type+      where+        SMkFoo3 :: forall (n :: Bool) (n :: Bool).+                   {sGetFoo3a :: (Sing (n :: Bool)), %*** :: (Sing (n :: Bool))}+                   -> SFoo3 (MkFoo3 n n)+    type instance Sing @Foo3 = SFoo3+    instance SingKind Foo3 where+      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) }+    instance SShow Foo1 where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Foo1) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo1 ((~>) Symbol Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        _+        SMkFoo1+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "MkFoo1")))+            sA_0123456789876543210+    instance SShow a => SShow (Foo2 a) where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Foo2 a) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Foo2 a) ((~>) Symbol Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SMkFoo2a (sArg_0123456789876543210 :: Sing arg_0123456789876543210)+                  (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "MkFoo2a "))))+                   ((applySing+                       ((applySing ((singFun3 @(.@#@$)) (%.)))+                          ((applySing+                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                 (sFromInteger (sing :: Sing 11))))+                             sArg_0123456789876543210)))+                      ((applySing+                          ((applySing ((singFun3 @(.@#@$)) (%.)))+                             ((singFun1 @ShowSpaceSym0) sShowSpace)))+                         ((applySing+                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                (sFromInteger (sing :: Sing 11))))+                            sArg_0123456789876543210))))))+            sA_0123456789876543210+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SMkFoo2b (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)+                  (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 5)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing+                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                              (sFromInteger (sing :: Sing 6))))+                          sArgL_0123456789876543210)))+                   ((applySing+                       ((applySing ((singFun3 @(.@#@$)) (%.)))+                          ((applySing ((singFun2 @ShowStringSym0) sShowString))+                             (sing :: Sing " `MkFoo2b` "))))+                      ((applySing+                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                             (sFromInteger (sing :: Sing 6))))+                         sArgR_0123456789876543210)))))+            sA_0123456789876543210+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        ((:%*:) (sArg_0123456789876543210 :: Sing arg_0123456789876543210)+                (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "(:*:) "))))+                   ((applySing+                       ((applySing ((singFun3 @(.@#@$)) (%.)))+                          ((applySing+                              ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                 (sFromInteger (sing :: Sing 11))))+                             sArg_0123456789876543210)))+                      ((applySing+                          ((applySing ((singFun3 @(.@#@$)) (%.)))+                             ((singFun1 @ShowSpaceSym0) sShowSpace)))+                         ((applySing+                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                (sFromInteger (sing :: Sing 11))))+                            sArg_0123456789876543210))))))+            sA_0123456789876543210+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        ((:%&:) (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)+                (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 5)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing+                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                              (sFromInteger (sing :: Sing 6))))+                          sArgL_0123456789876543210)))+                   ((applySing+                       ((applySing ((singFun3 @(.@#@$)) (%.)))+                          ((applySing ((singFun2 @ShowStringSym0) sShowString))+                             (sing :: Sing " :&: "))))+                      ((applySing+                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                             (sFromInteger (sing :: Sing 6))))+                         sArgR_0123456789876543210)))))+            sA_0123456789876543210+    instance SShow Bool => SShow Foo3 where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Foo3) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Foo3 ((~>) Symbol Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SMkFoo3 (sArg_0123456789876543210 :: Sing arg_0123456789876543210)+                 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "MkFoo3 "))))+                   ((applySing+                       ((applySing ((singFun3 @(.@#@$)) (%.)))+                          ((applySing ((singFun2 @ShowCharSym0) sShowChar))+                             (sing :: Sing "{"))))+                      ((applySing+                          ((applySing ((singFun3 @(.@#@$)) (%.)))+                             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                                (sing :: Sing "getFoo3a = "))))+                         ((applySing+                             ((applySing ((singFun3 @(.@#@$)) (%.)))+                                ((applySing+                                    ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                       (sFromInteger (sing :: Sing 0))))+                                   sArg_0123456789876543210)))+                            ((applySing+                                ((applySing ((singFun3 @(.@#@$)) (%.)))+                                   ((singFun1 @ShowCommaSpaceSym0) sShowCommaSpace)))+                               ((applySing+                                   ((applySing ((singFun3 @(.@#@$)) (%.)))+                                      ((applySing ((singFun2 @ShowStringSym0) sShowString))+                                         (sing :: Sing "(***) = "))))+                                  ((applySing+                                      ((applySing ((singFun3 @(.@#@$)) (%.)))+                                         ((applySing+                                             ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                                                (sFromInteger (sing :: Sing 0))))+                                            sArg_0123456789876543210)))+                                     ((applySing ((singFun2 @ShowCharSym0) sShowChar))+                                        (sing :: Sing "}")))))))))))+            sA_0123456789876543210+    instance Show (SFoo1 (z :: Foo1)) where+      showsPrec _ SMkFoo1 = showString "SMkFoo1"+    instance Data.Singletons.ShowSing.ShowSing a =>+             Show (SFoo2 (z :: Foo2 a)) where+      showsPrec+        p_0123456789876543210+        (SMkFoo2a (arg_0123456789876543210 :: Sing argTy_0123456789876543210)+                  (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SMkFoo2a "))+               (((.) ((showsPrec 11) arg_0123456789876543210))+                  (((.) GHC.Show.showSpace)+                     ((showsPrec 11) arg_0123456789876543210)))) ::+            (Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210) =>+            ShowS+      showsPrec+        p_0123456789876543210+        (SMkFoo2b (argL_0123456789876543210 :: Sing argTyL_0123456789876543210)+                  (argR_0123456789876543210 :: Sing argTyR_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 9))+            (((.) ((showsPrec 10) argL_0123456789876543210))+               (((.) (showString " `SMkFoo2b` "))+                  ((showsPrec 10) argR_0123456789876543210))) ::+            (Data.Singletons.ShowSing.ShowSing' argTyL_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTyR_0123456789876543210) =>+            ShowS+      showsPrec+        p_0123456789876543210+        ((:%*:) (arg_0123456789876543210 :: Sing argTy_0123456789876543210)+                (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "(:%*:) "))+               (((.) ((showsPrec 11) arg_0123456789876543210))+                  (((.) GHC.Show.showSpace)+                     ((showsPrec 11) arg_0123456789876543210)))) ::+            (Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210) =>+            ShowS+      showsPrec+        p_0123456789876543210+        ((:%&:) (argL_0123456789876543210 :: Sing argTyL_0123456789876543210)+                (argR_0123456789876543210 :: Sing argTyR_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 9))+            (((.) ((showsPrec 10) argL_0123456789876543210))+               (((.) (showString " :%&: "))+                  ((showsPrec 10) argR_0123456789876543210))) ::+            (Data.Singletons.ShowSing.ShowSing' argTyL_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTyR_0123456789876543210) =>+            ShowS+    instance Data.Singletons.ShowSing.ShowSing Bool =>+             Show (SFoo3 (z :: Foo3)) where+      showsPrec+        p_0123456789876543210+        (SMkFoo3 (arg_0123456789876543210 :: Sing argTy_0123456789876543210)+                 (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SMkFoo3 "))+               (((.) (showChar '{'))+                  (((.) (showString "sGetFoo3a = "))+                     (((.) ((showsPrec 0) arg_0123456789876543210))+                        (((.) GHC.Show.showCommaSpace)+                           (((.) (showString "(%***) = "))+                              (((.) ((showsPrec 0) arg_0123456789876543210))+                                 (showChar '}')))))))) ::+            (Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210) =>+            ShowS+    instance SingI MkFoo1 where+      sing = SMkFoo1+    instance (SingI n, SingI n) =>+             SingI (MkFoo2a (n :: a) (n :: a)) where+      sing = (SMkFoo2a sing) sing+    instance SingI (MkFoo2aSym0 :: (~>) a ((~>) a (Foo2 a))) where+      sing = (singFun2 @MkFoo2aSym0) SMkFoo2a+    instance SingI d =>+             SingI (MkFoo2aSym1 (d :: a) :: (~>) a (Foo2 a)) where+      sing = (singFun1 @(MkFoo2aSym1 (d :: a))) (SMkFoo2a (sing @d))+    instance (SingI n, SingI n) =>+             SingI (MkFoo2b (n :: a) (n :: a)) where+      sing = (SMkFoo2b sing) sing+    instance SingI (MkFoo2bSym0 :: (~>) a ((~>) a (Foo2 a))) where+      sing = (singFun2 @MkFoo2bSym0) SMkFoo2b+    instance SingI d =>+             SingI (MkFoo2bSym1 (d :: a) :: (~>) a (Foo2 a)) where+      sing = (singFun1 @(MkFoo2bSym1 (d :: a))) (SMkFoo2b (sing @d))+    instance (SingI n, SingI n) =>+             SingI ((:*:) (n :: a) (n :: a)) where+      sing = ((:%*:) sing) sing+    instance SingI ((:*:@#@$) :: (~>) a ((~>) a (Foo2 a))) where+      sing = (singFun2 @(:*:@#@$)) (:%*:)+    instance SingI d =>+             SingI ((:*:@#@$$) (d :: a) :: (~>) a (Foo2 a)) where+      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))+    instance (SingI n, SingI n) =>+             SingI ((:&:) (n :: a) (n :: a)) where+      sing = ((:%&:) sing) sing+    instance SingI ((:&:@#@$) :: (~>) a ((~>) a (Foo2 a))) where+      sing = (singFun2 @(:&:@#@$)) (:%&:)+    instance SingI d =>+             SingI ((:&:@#@$$) (d :: a) :: (~>) a (Foo2 a)) where+      sing = (singFun1 @((:&:@#@$$) (d :: a))) ((:%&:) (sing @d))+    instance (SingI n, SingI n) =>+             SingI (MkFoo3 (n :: Bool) (n :: Bool)) where+      sing = (SMkFoo3 sing) sing+    instance SingI (MkFoo3Sym0 :: (~>) Bool ((~>) Bool Foo3)) where+      sing = (singFun2 @MkFoo3Sym0) SMkFoo3+    instance SingI d =>+             SingI (MkFoo3Sym1 (d :: Bool) :: (~>) Bool Foo3) where+      sing = (singFun1 @(MkFoo3Sym1 (d :: Bool))) (SMkFoo3 (sing @d))
− tests/compile-and-dump/Singletons/StandaloneDeriving.ghc86.template 
@@ -1,447 +0,0 @@-Singletons/StandaloneDeriving.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| infixl 6 :*:-          -          data T a b = a :*: b-          data S = S1 | S2-          -          deriving instance Enum S-          deriving instance Bounded S-          deriving instance Show S-          deriving instance Ord S-          deriving instance Eq S-          deriving instance Show a => Show (T a ())-          deriving instance Ord a => Ord (T a ())-          deriving instance Eq a => Eq (T a ()) |]-  ======>-    infixl 6 :*:-    data T a b = a :*: b-    data S = S1 | S2-    deriving instance Eq a => Eq (T a ())-    deriving instance Ord a => Ord (T a ())-    deriving instance Show a => Show (T a ())-    deriving instance Eq S-    deriving instance Ord S-    deriving instance Show S-    deriving instance Bounded S-    deriving instance Enum S-    type (:*:@#@$$$) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =-        (:*:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:*:@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())-    data (:*:@#@$$) (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                      (~>) b0123456789876543210 (T a0123456789876543210 b0123456789876543210)-      where-        (::*:@#@$$###) :: forall t0123456789876543210-                                 t0123456789876543210-                                 arg. SameKind (Apply ((:*:@#@$$) t0123456789876543210) arg) ((:*:@#@$$$) t0123456789876543210 arg) =>-                          (:*:@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:*:@#@$$) t0123456789876543210) t0123456789876543210 = (:*:) t0123456789876543210 t0123456789876543210-    infixl 6 :*:@#@$$-    instance SuppressUnusedWarnings (:*:@#@$) where-      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())-    data (:*:@#@$) :: forall a0123456789876543210 b0123456789876543210.-                      (~>) a0123456789876543210 ((~>) b0123456789876543210 (T a0123456789876543210 b0123456789876543210))-      where-        (::*:@#@$###) :: forall t0123456789876543210-                                arg. SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>-                         (:*:@#@$) t0123456789876543210-    type instance Apply (:*:@#@$) t0123456789876543210 = (:*:@#@$$) t0123456789876543210-    infixl 6 :*:@#@$-    type S1Sym0 = S1-    type S2Sym0 = S2-    type family Compare_0123456789876543210 (a :: T a ()) (a :: T a ()) :: Ordering where-      Compare_0123456789876543210 ((:*:) a_0123456789876543210 a_0123456789876543210) ((:*:) b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: T a0123456789876543210 ()) (a0123456789876543210 :: T a0123456789876543210 ()) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: T a0123456789876543210 ()) :: (~>) (T a0123456789876543210 ()) Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: forall a0123456789876543210.-                                            (~>) (T a0123456789876543210 ()) ((~>) (T a0123456789876543210 ()) Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd (T a ()) where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T a0123456789876543210 ()) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T a0123456789876543210 ()) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.-                                                                                      (~>) (T a0123456789876543210 ()) ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.-                                              (~>) GHC.Types.Nat ((~>) (T a0123456789876543210 ()) ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow (T a ()) where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family Compare_0123456789876543210 (a :: S) (a :: S) :: Ordering where-      Compare_0123456789876543210 S1 S1 = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 S2 S2 = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 S1 S2 = LTSym0-      Compare_0123456789876543210 S2 S1 = GTSym0-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: S) (a0123456789876543210 :: S) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: S) :: (~>) S Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) S ((~>) S Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd S where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: S) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: S) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) S ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) S ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow S where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family MinBound_0123456789876543210 :: S where-      MinBound_0123456789876543210 = S1Sym0-    type MinBound_0123456789876543210Sym0 =-        MinBound_0123456789876543210-    type family MaxBound_0123456789876543210 :: S where-      MaxBound_0123456789876543210 = S2Sym0-    type MaxBound_0123456789876543210Sym0 =-        MaxBound_0123456789876543210-    instance PBounded S where-      type MinBound = MinBound_0123456789876543210Sym0-      type MaxBound = MaxBound_0123456789876543210Sym0-    type family Case_0123456789876543210 n t where-      Case_0123456789876543210 n  'True = S2Sym0-      Case_0123456789876543210 n  'False = Apply ErrorSym0 "toEnum: bad argument"-    type family Case_0123456789876543210 n t where-      Case_0123456789876543210 n  'True = S1Sym0-      Case_0123456789876543210 n  'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1))-    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: S where-      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))-    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =-        ToEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat S-      where-        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210-    type family FromEnum_0123456789876543210 (a :: S) :: GHC.Types.Nat where-      FromEnum_0123456789876543210 S1 = FromInteger 0-      FromEnum_0123456789876543210 S2 = FromInteger 1-    type FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: S) =-        FromEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())-    data FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Types.Nat-      where-        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210-    instance PEnum S where-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a-    type family Equals_0123456789876543210 (a :: T a ()) (b :: T a ()) :: Bool where-      Equals_0123456789876543210 ((:*:) a a) ((:*:) b b) = (&&) ((==) a b) ((==) a b)-      Equals_0123456789876543210 (_ :: T a ()) (_ :: T a ()) = FalseSym0-    instance PEq (T a ()) where-      type (==) a b = Equals_0123456789876543210 a b-    type family Equals_0123456789876543210 (a :: S) (b :: S) :: Bool where-      Equals_0123456789876543210 S1 S1 = TrueSym0-      Equals_0123456789876543210 S2 S2 = TrueSym0-      Equals_0123456789876543210 (_ :: S) (_ :: S) = FalseSym0-    instance PEq S where-      type (==) a b = Equals_0123456789876543210 a b-    infixl 6 :%*:-    data instance Sing :: T a b -> GHC.Types.Type-      where-        (:%*:) :: forall a b (n :: a) (n :: b).-                  (Sing (n :: a)) -> (Sing (n :: b)) -> Sing ((:*:) n n)-    type ST = (Sing :: T a b -> GHC.Types.Type)-    instance (SingKind a, SingKind b) => SingKind (T a b) where-      type Demote (T a b) = T (Demote a) (Demote b)-      fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b)-      toSing ((:*:) (b :: Demote a) (b :: Demote b))-        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of {-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) }-    data instance Sing :: S -> GHC.Types.Type-      where-        SS1 :: Sing S1-        SS2 :: Sing S2-    type SS = (Sing :: S -> GHC.Types.Type)-    instance SingKind S where-      type Demote S = S-      fromSing SS1 = S1-      fromSing SS2 = S2-      toSing S1 = SomeSing SS1-      toSing S2 = SomeSing SS2-    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)-                                                 -> GHC.Types.Type) t1) t2)-      sCompare-        ((:%*:) (sA_0123456789876543210 :: Sing a_0123456789876543210)-                (sA_0123456789876543210 :: Sing a_0123456789876543210))-        ((:%*:) (sB_0123456789876543210 :: Sing b_0123456789876543210)-                (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               ((applySing-                   ((applySing ((singFun2 @(:@#@$)) SCons))-                      ((applySing-                          ((applySing ((singFun2 @CompareSym0) sCompare))-                             sA_0123456789876543210))-                         sB_0123456789876543210)))-                  SNil))-    instance SShow a => SShow (T a ()) where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: T a ()) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (T a ()) ((~>) Symbol Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        ((:%*:) (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)-                (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 6)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing-                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                              (sFromInteger (sing :: Sing 7))))-                          sArgL_0123456789876543210)))-                   ((applySing-                       ((applySing ((singFun3 @(.@#@$)) (%.)))-                          ((applySing ((singFun2 @ShowStringSym0) sShowString))-                             (sing :: Sing " :*: "))))-                      ((applySing-                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                             (sFromInteger (sing :: Sing 7))))-                         sArgR_0123456789876543210)))))-            sA_0123456789876543210-    instance SOrd S where-      sCompare ::-        forall (t1 :: S) (t2 :: S).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun S ((~>) S Ordering)-                                                 -> GHC.Types.Type) t1) t2)-      sCompare SS1 SS1-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            SNil-      sCompare SS2 SS2-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            SNil-      sCompare SS1 SS2 = SLT-      sCompare SS2 SS1 = SGT-    instance SShow S where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: S) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) S ((~>) Symbol Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        _-        SS1-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "S1")))-            sA_0123456789876543210-      sShowsPrec-        _-        SS2-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "S2")))-            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.Types.Nat).-        Sing t-        -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Types.Nat S-                                      -> GHC.Types.Type) t)-      sFromEnum ::-        forall (t :: S).-        Sing t-        -> Sing (Apply (FromEnumSym0 :: TyFun S GHC.Types.Nat-                                        -> GHC.Types.Type) t)-      sToEnum (sN :: Sing n)-        = (case-               (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))-                 (sFromInteger (sing :: Sing 0))-           of-             STrue -> SS1-             SFalse-               -> (case-                       (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))-                         (sFromInteger (sing :: Sing 1))-                   of-                     STrue -> SS2-                     SFalse -> sError (sing :: Sing "toEnum: bad argument")) ::-                    Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1)))) ::-            Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0)))-      sFromEnum SS1 = sFromInteger (sing :: Sing 0)-      sFromEnum SS2 = sFromInteger (sing :: Sing 1)-    instance SEq a => SEq (T a ()) where-      (%==) ((:%*:) a a) ((:%*:) b b)-        = ((%&&) (((%==) a) b)) (((%==) a) b)-    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 })-    instance SEq S where-      (%==) SS1 SS1 = STrue-      (%==) SS1 SS2 = SFalse-      (%==) SS2 SS1 = SFalse-      (%==) SS2 SS2 = STrue-    instance SDecide S where-      (%~) SS1 SS1 = Proved Refl-      (%~) SS1 SS2 = Disproved (\ x -> case x of)-      (%~) SS2 SS1 = Disproved (\ x -> case x of)-      (%~) SS2 SS2 = Proved Refl-    deriving instance Data.Singletons.ShowSing.ShowSing a =>-                      Show (Sing (z :: T a ()))-    deriving instance Show (Sing (z :: S))-    instance (SingI n, SingI n) =>-             SingI ((:*:) (n :: a) (n :: b)) where-      sing = ((:%*:) sing) sing-    instance SingI ((:*:@#@$) :: (~>) a ((~>) b (T a b))) where-      sing = (singFun2 @(:*:@#@$)) (:%*:)-    instance SingI (TyCon2 (:*:) :: (~>) a ((~>) b (T a b))) where-      sing = (singFun2 @(TyCon2 (:*:))) (:%*:)-    instance SingI d =>-             SingI ((:*:@#@$$) (d :: a) :: (~>) b (T a b)) where-      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ((:*:) (d :: a)) :: (~>) b (T a b)) where-      sing = (singFun1 @(TyCon1 ((:*:) (d :: a)))) ((:%*:) (sing @d))-    instance SingI S1 where-      sing = SS1-    instance SingI S2 where-      sing = SS2
+ tests/compile-and-dump/Singletons/StandaloneDeriving.ghc88.template view
@@ -0,0 +1,475 @@+Singletons/StandaloneDeriving.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| infixl 6 :*:+          +          data T a b = a :*: b+          data S = S1 | S2+          +          deriving instance Enum S+          deriving instance Bounded S+          deriving instance Show S+          deriving instance Ord S+          deriving instance Eq S+          deriving instance Show a => Show (T a ())+          deriving instance Ord a => Ord (T a ())+          deriving instance Eq a => Eq (T a ()) |]+  ======>+    infixl 6 :*:+    data T a b = a :*: b+    data S = S1 | S2+    deriving instance Eq a => Eq (T a ())+    deriving instance Ord a => Ord (T a ())+    deriving instance Show a => Show (T a ())+    deriving instance Eq S+    deriving instance Ord S+    deriving instance Show S+    deriving instance Bounded S+    deriving instance Enum S+    type (:*:@#@$$$) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =+        (:*:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:*:@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())+    data (:*:@#@$$) (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                      (~>) b0123456789876543210 (T a0123456789876543210 b0123456789876543210)+      where+        (::*:@#@$$###) :: forall t0123456789876543210+                                 t0123456789876543210+                                 arg. SameKind (Apply ((:*:@#@$$) t0123456789876543210) arg) ((:*:@#@$$$) t0123456789876543210 arg) =>+                          (:*:@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:*:@#@$$) t0123456789876543210) t0123456789876543210 = (:*:) t0123456789876543210 t0123456789876543210+    infixl 6 :*:@#@$$+    instance SuppressUnusedWarnings (:*:@#@$) where+      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())+    data (:*:@#@$) :: forall a0123456789876543210 b0123456789876543210.+                      (~>) a0123456789876543210 ((~>) b0123456789876543210 (T a0123456789876543210 b0123456789876543210))+      where+        (::*:@#@$###) :: forall t0123456789876543210+                                arg. SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>+                         (:*:@#@$) t0123456789876543210+    type instance Apply (:*:@#@$) t0123456789876543210 = (:*:@#@$$) t0123456789876543210+    infixl 6 :*:@#@$+    type S1Sym0 = S1+    type S2Sym0 = S2+    type family Compare_0123456789876543210 (a :: T a ()) (a :: T a ()) :: Ordering where+      Compare_0123456789876543210 ((:*:) a_0123456789876543210 a_0123456789876543210) ((:*:) b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: T a0123456789876543210 ()) (a0123456789876543210 :: T a0123456789876543210 ()) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: T a0123456789876543210 ()) :: (~>) (T a0123456789876543210 ()) Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: forall a0123456789876543210.+                                            (~>) (T a0123456789876543210 ()) ((~>) (T a0123456789876543210 ()) Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd (T a ()) where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T a0123456789876543210 ()) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T a0123456789876543210 ()) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.+                                                                                      (~>) (T a0123456789876543210 ()) ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.+                                              (~>) GHC.Types.Nat ((~>) (T a0123456789876543210 ()) ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow (T a ()) where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family Compare_0123456789876543210 (a :: S) (a :: S) :: Ordering where+      Compare_0123456789876543210 S1 S1 = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 S2 S2 = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 S1 S2 = LTSym0+      Compare_0123456789876543210 S2 S1 = GTSym0+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: S) (a0123456789876543210 :: S) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: S) :: (~>) S Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) S ((~>) S Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd S where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: S) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: S) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) S ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) S ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow S where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family MinBound_0123456789876543210 :: S where+      MinBound_0123456789876543210 = S1Sym0+    type MinBound_0123456789876543210Sym0 =+        MinBound_0123456789876543210+    type family MaxBound_0123456789876543210 :: S where+      MaxBound_0123456789876543210 = S2Sym0+    type MaxBound_0123456789876543210Sym0 =+        MaxBound_0123456789876543210+    instance PBounded S where+      type MinBound = MinBound_0123456789876543210Sym0+      type MaxBound = MaxBound_0123456789876543210Sym0+    type family Case_0123456789876543210 n t where+      Case_0123456789876543210 n 'True = S2Sym0+      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+    type family Case_0123456789876543210 n t where+      Case_0123456789876543210 n 'True = S1Sym0+      Case_0123456789876543210 n 'False = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 1))+    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: S where+      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (FromInteger 0))+    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =+        ToEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())+    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat S+      where+        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>+                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210+    type family FromEnum_0123456789876543210 (a :: S) :: GHC.Types.Nat where+      FromEnum_0123456789876543210 S1 = FromInteger 0+      FromEnum_0123456789876543210 S2 = FromInteger 1+    type FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: S) =+        FromEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())+    data FromEnum_0123456789876543210Sym0 :: (~>) S GHC.Types.Nat+      where+        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>+                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210+    instance PEnum S where+      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a+      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a+    type family Equals_0123456789876543210 (a :: T a ()) (b :: T a ()) :: Bool where+      Equals_0123456789876543210 ((:*:) a a) ((:*:) b b) = (&&) ((==) a b) ((==) a b)+      Equals_0123456789876543210 (_ :: T a ()) (_ :: T a ()) = FalseSym0+    instance PEq (T a ()) where+      type (==) a b = Equals_0123456789876543210 a b+    type family Equals_0123456789876543210 (a :: S) (b :: S) :: Bool where+      Equals_0123456789876543210 S1 S1 = TrueSym0+      Equals_0123456789876543210 S2 S2 = TrueSym0+      Equals_0123456789876543210 (_ :: S) (_ :: S) = FalseSym0+    instance PEq S where+      type (==) a b = Equals_0123456789876543210 a b+    infixl 6 :%*:+    data ST :: forall a b. T a b -> GHC.Types.Type+      where+        (:%*:) :: forall a b (n :: a) (n :: b).+                  (Sing (n :: a)) -> (Sing (n :: b)) -> ST ((:*:) n n)+    type instance Sing @(T a b) = ST+    instance (SingKind a, SingKind b) => SingKind (T a b) where+      type Demote (T a b) = T (Demote a) (Demote b)+      fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b)+      toSing ((:*:) (b :: Demote a) (b :: Demote b))+        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of {+            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) }+    data SS :: S -> GHC.Types.Type+      where+        SS1 :: SS S1+        SS2 :: SS S2+    type instance Sing @S = SS+    instance SingKind S where+      type Demote S = S+      fromSing SS1 = S1+      fromSing SS2 = S2+      toSing S1 = SomeSing SS1+      toSing S2 = SomeSing SS2+    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)+                                                 -> GHC.Types.Type) t1) t2)+      sCompare+        ((:%*:) (sA_0123456789876543210 :: Sing a_0123456789876543210)+                (sA_0123456789876543210 :: Sing a_0123456789876543210))+        ((:%*:) (sB_0123456789876543210 :: Sing b_0123456789876543210)+                (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @(:@#@$)) SCons))+                      ((applySing+                          ((applySing ((singFun2 @CompareSym0) sCompare))+                             sA_0123456789876543210))+                         sB_0123456789876543210)))+                  SNil))+    instance SShow a => SShow (T a ()) where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: T a ()) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (T a ()) ((~>) Symbol Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        ((:%*:) (sArgL_0123456789876543210 :: Sing argL_0123456789876543210)+                (sArgR_0123456789876543210 :: Sing argR_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 6)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing+                           ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                              (sFromInteger (sing :: Sing 7))))+                          sArgL_0123456789876543210)))+                   ((applySing+                       ((applySing ((singFun3 @(.@#@$)) (%.)))+                          ((applySing ((singFun2 @ShowStringSym0) sShowString))+                             (sing :: Sing " :*: "))))+                      ((applySing+                          ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                             (sFromInteger (sing :: Sing 7))))+                         sArgR_0123456789876543210)))))+            sA_0123456789876543210+    instance SOrd S where+      sCompare ::+        forall (t1 :: S) (t2 :: S).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun S ((~>) S Ordering)+                                                 -> GHC.Types.Type) t1) t2)+      sCompare SS1 SS1+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            SNil+      sCompare SS2 SS2+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            SNil+      sCompare SS1 SS2 = SLT+      sCompare SS2 SS1 = SGT+    instance SShow S where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: S) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) S ((~>) Symbol Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        _+        SS1+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "S1")))+            sA_0123456789876543210+      sShowsPrec+        _+        SS2+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "S2")))+            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.Types.Nat).+        Sing t+        -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Types.Nat S+                                      -> GHC.Types.Type) t)+      sFromEnum ::+        forall (t :: S).+        Sing t+        -> Sing (Apply (FromEnumSym0 :: TyFun S GHC.Types.Nat+                                        -> GHC.Types.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")))+      sFromEnum SS1 = sFromInteger (sing :: Sing 0)+      sFromEnum SS2 = sFromInteger (sing :: Sing 1)+    instance SEq a => SEq (T a ()) where+      (%==) ((:%*:) a a) ((:%*:) b b)+        = ((%&&) (((%==) a) b)) (((%==) a) b)+    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 })+    instance SDecide a =>+             Data.Type.Equality.TestEquality (ST :: T a ()+                                                    -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance SDecide a =>+             Data.Type.Coercion.TestCoercion (ST :: T a ()+                                                    -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance SEq S where+      (%==) SS1 SS1 = STrue+      (%==) SS1 SS2 = SFalse+      (%==) SS2 SS1 = SFalse+      (%==) SS2 SS2 = STrue+    instance SDecide S where+      (%~) SS1 SS1 = Proved Refl+      (%~) SS1 SS2 = Disproved (\ x -> case x of)+      (%~) SS2 SS1 = Disproved (\ x -> case x of)+      (%~) SS2 SS2 = Proved Refl+    instance Data.Type.Equality.TestEquality (SS :: S+                                                    -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance Data.Type.Coercion.TestCoercion (SS :: S+                                                    -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance Data.Singletons.ShowSing.ShowSing a =>+             Show (ST (z :: T a ())) where+      showsPrec+        p_0123456789876543210+        ((:%*:) (argL_0123456789876543210 :: Sing argTyL_0123456789876543210)+                (argR_0123456789876543210 :: Sing argTyR_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 9))+            (((.) ((showsPrec 10) argL_0123456789876543210))+               (((.) (showString " :%*: "))+                  ((showsPrec 10) argR_0123456789876543210))) ::+            (Data.Singletons.ShowSing.ShowSing' argTyL_0123456789876543210,+             Data.Singletons.ShowSing.ShowSing' argTyR_0123456789876543210) =>+            ShowS+    instance Show (SS (z :: S)) where+      showsPrec _ SS1 = showString "SS1"+      showsPrec _ SS2 = showString "SS2"+    instance (SingI n, SingI n) =>+             SingI ((:*:) (n :: a) (n :: b)) where+      sing = ((:%*:) sing) sing+    instance SingI ((:*:@#@$) :: (~>) a ((~>) b (T a b))) where+      sing = (singFun2 @(:*:@#@$)) (:%*:)+    instance SingI d =>+             SingI ((:*:@#@$$) (d :: a) :: (~>) b (T a b)) where+      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))+    instance SingI S1 where+      sing = SS1+    instance SingI S2 where+      sing = SS2
− tests/compile-and-dump/Singletons/Star.ghc86.template 
@@ -1,422 +0,0 @@-Singletons/Star.hs:0:0:: Splicing declarations-    singletonStar [''Nat, ''Int, ''String, ''Maybe, ''Vec]-  ======>-    data Rep :: Type-      where-        Singletons.Star.Nat :: Rep-        Singletons.Star.Int :: Rep-        Singletons.Star.String :: Rep-        Singletons.Star.Maybe :: Rep -> Rep-        Singletons.Star.Vec :: Rep -> Nat -> Rep-      deriving (Eq, Ord, Read, Show)-    type NatSym0 = Nat-    type IntSym0 = Int-    type StringSym0 = String-    type MaybeSym1 (t0123456789876543210 :: Type) =-        Maybe t0123456789876543210-    instance SuppressUnusedWarnings MaybeSym0 where-      suppressUnusedWarnings = snd (((,) MaybeSym0KindInference) ())-    data MaybeSym0 :: (~>) Type Type-      where-        MaybeSym0KindInference :: forall t0123456789876543210-                                         arg. SameKind (Apply MaybeSym0 arg) (MaybeSym1 arg) =>-                                  MaybeSym0 t0123456789876543210-    type instance Apply MaybeSym0 t0123456789876543210 = Maybe t0123456789876543210-    type VecSym2 (t0123456789876543210 :: Type) (t0123456789876543210 :: Nat) =-        Vec t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (VecSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) VecSym1KindInference) ())-    data VecSym1 (t0123456789876543210 :: Type) :: (~>) Nat Type-      where-        VecSym1KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (VecSym1 t0123456789876543210) arg) (VecSym2 t0123456789876543210 arg) =>-                                VecSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (VecSym1 t0123456789876543210) t0123456789876543210 = Vec t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings VecSym0 where-      suppressUnusedWarnings = snd (((,) VecSym0KindInference) ())-    data VecSym0 :: (~>) Type ((~>) Nat Type)-      where-        VecSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply VecSym0 arg) (VecSym1 arg) =>-                                VecSym0 t0123456789876543210-    type instance Apply VecSym0 t0123456789876543210 = VecSym1 t0123456789876543210-    type family Equals_0123456789876543210 (a :: Type) (b :: Type) :: Bool where-      Equals_0123456789876543210 Nat Nat = TrueSym0-      Equals_0123456789876543210 Int Int = TrueSym0-      Equals_0123456789876543210 String String = TrueSym0-      Equals_0123456789876543210 (Maybe a) (Maybe b) = (==) a b-      Equals_0123456789876543210 (Vec a a) (Vec b b) = (&&) ((==) a b) ((==) a b)-      Equals_0123456789876543210 (_ :: Type) (_ :: Type) = FalseSym0-    instance PEq Type where-      type (==) a b = Equals_0123456789876543210 a b-    type family Compare_0123456789876543210 (a :: Type) (a :: Type) :: Ordering where-      Compare_0123456789876543210 Nat Nat = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 Int Int = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 String String = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 (Maybe a_0123456789876543210) (Maybe b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])-      Compare_0123456789876543210 (Vec a_0123456789876543210 a_0123456789876543210) (Vec b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))-      Compare_0123456789876543210 Nat Int = LTSym0-      Compare_0123456789876543210 Nat String = LTSym0-      Compare_0123456789876543210 Nat (Maybe _) = LTSym0-      Compare_0123456789876543210 Nat (Vec _ _) = LTSym0-      Compare_0123456789876543210 Int Nat = GTSym0-      Compare_0123456789876543210 Int String = LTSym0-      Compare_0123456789876543210 Int (Maybe _) = LTSym0-      Compare_0123456789876543210 Int (Vec _ _) = LTSym0-      Compare_0123456789876543210 String Nat = GTSym0-      Compare_0123456789876543210 String Int = GTSym0-      Compare_0123456789876543210 String (Maybe _) = LTSym0-      Compare_0123456789876543210 String (Vec _ _) = LTSym0-      Compare_0123456789876543210 (Maybe _) Nat = GTSym0-      Compare_0123456789876543210 (Maybe _) Int = GTSym0-      Compare_0123456789876543210 (Maybe _) String = GTSym0-      Compare_0123456789876543210 (Maybe _) (Vec _ _) = LTSym0-      Compare_0123456789876543210 (Vec _ _) Nat = GTSym0-      Compare_0123456789876543210 (Vec _ _) Int = GTSym0-      Compare_0123456789876543210 (Vec _ _) String = GTSym0-      Compare_0123456789876543210 (Vec _ _) (Maybe _) = GTSym0-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Type) (a0123456789876543210 :: Type) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Type) :: (~>) Type Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) Type ((~>) Type Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd Type where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Type) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Type) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Type ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Type ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow Type where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    data instance Sing :: Type -> Type-      where-        SNat :: Sing Nat-        SInt :: Sing Int-        SString :: Sing String-        SMaybe :: forall (n :: Type). (Sing (n :: Type)) -> Sing (Maybe n)-        SVec :: forall (n :: Type) (n :: Nat).-                (Sing (n :: Type)) -> (Sing (n :: Nat)) -> Sing (Vec n n)-    type SRep = (Sing :: Type -> Type)-    instance SingKind Type where-      type Demote Type = Rep-      fromSing SNat = Singletons.Star.Nat-      fromSing SInt = Singletons.Star.Int-      fromSing SString = Singletons.Star.String-      fromSing (SMaybe b) = Singletons.Star.Maybe (fromSing b)-      fromSing (SVec b b)-        = (Singletons.Star.Vec (fromSing b)) (fromSing b)-      toSing Singletons.Star.Nat = SomeSing SNat-      toSing Singletons.Star.Int = SomeSing SInt-      toSing Singletons.Star.String = SomeSing SString-      toSing (Singletons.Star.Maybe (b :: Demote Type))-        = case toSing b :: SomeSing Type of {-            SomeSing c -> SomeSing (SMaybe c) }-      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) }-    instance (SEq Type, SEq Nat) => SEq Type where-      (%==) SNat SNat = STrue-      (%==) SNat SInt = SFalse-      (%==) SNat SString = SFalse-      (%==) SNat (SMaybe _) = SFalse-      (%==) SNat (SVec _ _) = SFalse-      (%==) SInt SNat = SFalse-      (%==) SInt SInt = STrue-      (%==) SInt SString = SFalse-      (%==) SInt (SMaybe _) = SFalse-      (%==) SInt (SVec _ _) = SFalse-      (%==) SString SNat = SFalse-      (%==) SString SInt = SFalse-      (%==) SString SString = STrue-      (%==) SString (SMaybe _) = SFalse-      (%==) SString (SVec _ _) = SFalse-      (%==) (SMaybe _) SNat = SFalse-      (%==) (SMaybe _) SInt = SFalse-      (%==) (SMaybe _) SString = SFalse-      (%==) (SMaybe a) (SMaybe b) = ((%==) a) b-      (%==) (SMaybe _) (SVec _ _) = SFalse-      (%==) (SVec _ _) SNat = SFalse-      (%==) (SVec _ _) SInt = SFalse-      (%==) (SVec _ _) SString = SFalse-      (%==) (SVec _ _) (SMaybe _) = SFalse-      (%==) (SVec a a) (SVec b b) = ((%&&) (((%==) a) b)) (((%==) a) b)-    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)-      (%~) 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)-      (%~) 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)-      (%~) (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)-      (%~) (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 (SOrd Type, SOrd Nat) => SOrd Type where-      sCompare ::-        forall (t1 :: Type) (t2 :: Type).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun Type ((~>) Type Ordering)-                                                 -> Type) t1) t2)-      sCompare SNat SNat-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            SNil-      sCompare SInt SInt-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            SNil-      sCompare SString SString-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            SNil-      sCompare-        (SMaybe (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SMaybe (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               SNil)-      sCompare-        (SVec (sA_0123456789876543210 :: Sing a_0123456789876543210)-              (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SVec (sB_0123456789876543210 :: Sing b_0123456789876543210)-              (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing ((singFun2 @(:@#@$)) SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               ((applySing-                   ((applySing ((singFun2 @(:@#@$)) SCons))-                      ((applySing-                          ((applySing ((singFun2 @CompareSym0) sCompare))-                             sA_0123456789876543210))-                         sB_0123456789876543210)))-                  SNil))-      sCompare SNat SInt = SLT-      sCompare SNat SString = SLT-      sCompare SNat (SMaybe _) = SLT-      sCompare SNat (SVec _ _) = SLT-      sCompare SInt SNat = SGT-      sCompare SInt SString = SLT-      sCompare SInt (SMaybe _) = SLT-      sCompare SInt (SVec _ _) = SLT-      sCompare SString SNat = SGT-      sCompare SString SInt = SGT-      sCompare SString (SMaybe _) = SLT-      sCompare SString (SVec _ _) = SLT-      sCompare (SMaybe _) SNat = SGT-      sCompare (SMaybe _) SInt = SGT-      sCompare (SMaybe _) SString = SGT-      sCompare (SMaybe _) (SVec _ _) = SLT-      sCompare (SVec _ _) SNat = SGT-      sCompare (SVec _ _) SInt = SGT-      sCompare (SVec _ _) SString = SGT-      sCompare (SVec _ _) (SMaybe _) = SGT-    instance (SShow Type, SShow Nat) => SShow Type where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Type) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Type ((~>) Symbol Symbol))-                                                             -> Type) t1) t2) t3)-      sShowsPrec-        _-        SNat-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "Nat")))-            sA_0123456789876543210-      sShowsPrec-        _-        SInt-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "Int")))-            sA_0123456789876543210-      sShowsPrec-        _-        SString-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "String")))-            sA_0123456789876543210-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SMaybe (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "Maybe "))))-                   ((applySing-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                          (sFromInteger (sing :: Sing 11))))-                      sArg_0123456789876543210))))-            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 SingI Nat where-      sing = SNat-    instance SingI Int where-      sing = SInt-    instance SingI String where-      sing = SString-    instance SingI n => SingI (Maybe (n :: Type)) where-      sing = SMaybe sing-    instance SingI (MaybeSym0 :: (~>) Type Type) where-      sing = (singFun1 @MaybeSym0) SMaybe-    instance SingI (TyCon1 Maybe :: (~>) Type Type) where-      sing = (singFun1 @(TyCon1 Maybe)) SMaybe-    instance (SingI n, SingI n) =>-             SingI (Vec (n :: Type) (n :: Nat)) where-      sing = (SVec sing) sing-    instance SingI (VecSym0 :: (~>) Type ((~>) Nat Type)) where-      sing = (singFun2 @VecSym0) SVec-    instance SingI (TyCon2 Vec :: (~>) Type ((~>) Nat Type)) where-      sing = (singFun2 @(TyCon2 Vec)) SVec-    instance SingI d =>-             SingI (VecSym1 (d :: Type) :: (~>) Nat Type) where-      sing = (singFun1 @(VecSym1 (d :: Type))) (SVec (sing @d))-    instance SingI d =>-             SingI (TyCon1 (Vec (d :: Type)) :: (~>) Nat Type) where-      sing = (singFun1 @(TyCon1 (Vec (d :: Type)))) (SVec (sing @d))
+ tests/compile-and-dump/Singletons/Star.ghc88.template view
@@ -0,0 +1,421 @@+Singletons/Star.hs:0:0:: Splicing declarations+    singletonStar [''Nat, ''Int, ''String, ''Maybe, ''Vec]+  ======>+    data Rep :: Type+      where+        Singletons.Star.Nat :: Rep+        Singletons.Star.Int :: Rep+        Singletons.Star.String :: Rep+        Singletons.Star.Maybe :: Rep -> Rep+        Singletons.Star.Vec :: Rep -> Nat -> Rep+      deriving (Eq, Ord, Read, Show)+    type NatSym0 = Nat+    type IntSym0 = Int+    type StringSym0 = String+    type MaybeSym1 (t0123456789876543210 :: Type) =+        Maybe t0123456789876543210+    instance SuppressUnusedWarnings MaybeSym0 where+      suppressUnusedWarnings = snd (((,) MaybeSym0KindInference) ())+    data MaybeSym0 :: (~>) Type Type+      where+        MaybeSym0KindInference :: forall t0123456789876543210+                                         arg. SameKind (Apply MaybeSym0 arg) (MaybeSym1 arg) =>+                                  MaybeSym0 t0123456789876543210+    type instance Apply MaybeSym0 t0123456789876543210 = Maybe t0123456789876543210+    type VecSym2 (t0123456789876543210 :: Type) (t0123456789876543210 :: Nat) =+        Vec t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (VecSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) VecSym1KindInference) ())+    data VecSym1 (t0123456789876543210 :: Type) :: (~>) Nat Type+      where+        VecSym1KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (VecSym1 t0123456789876543210) arg) (VecSym2 t0123456789876543210 arg) =>+                                VecSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (VecSym1 t0123456789876543210) t0123456789876543210 = Vec t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings VecSym0 where+      suppressUnusedWarnings = snd (((,) VecSym0KindInference) ())+    data VecSym0 :: (~>) Type ((~>) Nat Type)+      where+        VecSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply VecSym0 arg) (VecSym1 arg) =>+                                VecSym0 t0123456789876543210+    type instance Apply VecSym0 t0123456789876543210 = VecSym1 t0123456789876543210+    type family Equals_0123456789876543210 (a :: Type) (b :: Type) :: Bool where+      Equals_0123456789876543210 Nat Nat = TrueSym0+      Equals_0123456789876543210 Int Int = TrueSym0+      Equals_0123456789876543210 String String = TrueSym0+      Equals_0123456789876543210 (Maybe a) (Maybe b) = (==) a b+      Equals_0123456789876543210 (Vec a a) (Vec b b) = (&&) ((==) a b) ((==) a b)+      Equals_0123456789876543210 (_ :: Type) (_ :: Type) = FalseSym0+    instance PEq Type where+      type (==) a b = Equals_0123456789876543210 a b+    type family Compare_0123456789876543210 (a :: Type) (a :: Type) :: Ordering where+      Compare_0123456789876543210 Nat Nat = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 Int Int = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 String String = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 (Maybe a_0123456789876543210) (Maybe b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])+      Compare_0123456789876543210 (Vec a_0123456789876543210 a_0123456789876543210) (Vec b_0123456789876543210 b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[]))+      Compare_0123456789876543210 Nat Int = LTSym0+      Compare_0123456789876543210 Nat String = LTSym0+      Compare_0123456789876543210 Nat (Maybe _) = LTSym0+      Compare_0123456789876543210 Nat (Vec _ _) = LTSym0+      Compare_0123456789876543210 Int Nat = GTSym0+      Compare_0123456789876543210 Int String = LTSym0+      Compare_0123456789876543210 Int (Maybe _) = LTSym0+      Compare_0123456789876543210 Int (Vec _ _) = LTSym0+      Compare_0123456789876543210 String Nat = GTSym0+      Compare_0123456789876543210 String Int = GTSym0+      Compare_0123456789876543210 String (Maybe _) = LTSym0+      Compare_0123456789876543210 String (Vec _ _) = LTSym0+      Compare_0123456789876543210 (Maybe _) Nat = GTSym0+      Compare_0123456789876543210 (Maybe _) Int = GTSym0+      Compare_0123456789876543210 (Maybe _) String = GTSym0+      Compare_0123456789876543210 (Maybe _) (Vec _ _) = LTSym0+      Compare_0123456789876543210 (Vec _ _) Nat = GTSym0+      Compare_0123456789876543210 (Vec _ _) Int = GTSym0+      Compare_0123456789876543210 (Vec _ _) String = GTSym0+      Compare_0123456789876543210 (Vec _ _) (Maybe _) = GTSym0+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Type) (a0123456789876543210 :: Type) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Type) :: (~>) Type Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) Type ((~>) Type Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd Type where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Type) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Type) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) Type ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) Type ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow Type where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    data SRep :: Type -> Type+      where+        SNat :: SRep Nat+        SInt :: SRep Int+        SString :: SRep String+        SMaybe :: forall (n :: Type). (Sing (n :: Type)) -> SRep (Maybe n)+        SVec :: forall (n :: Type) (n :: Nat).+                (Sing (n :: Type)) -> (Sing (n :: Nat)) -> SRep (Vec n n)+    type instance Sing @Type = SRep+    instance SingKind Type where+      type Demote Type = Rep+      fromSing SNat = Singletons.Star.Nat+      fromSing SInt = Singletons.Star.Int+      fromSing SString = Singletons.Star.String+      fromSing (SMaybe b) = Singletons.Star.Maybe (fromSing b)+      fromSing (SVec b b)+        = (Singletons.Star.Vec (fromSing b)) (fromSing b)+      toSing Singletons.Star.Nat = SomeSing SNat+      toSing Singletons.Star.Int = SomeSing SInt+      toSing Singletons.Star.String = SomeSing SString+      toSing (Singletons.Star.Maybe (b :: Demote Type))+        = case toSing b :: SomeSing Type of {+            SomeSing c -> SomeSing (SMaybe c) }+      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) }+    instance (SEq Type, SEq Nat) => SEq Type where+      (%==) SNat SNat = STrue+      (%==) SNat SInt = SFalse+      (%==) SNat SString = SFalse+      (%==) SNat (SMaybe _) = SFalse+      (%==) SNat (SVec _ _) = SFalse+      (%==) SInt SNat = SFalse+      (%==) SInt SInt = STrue+      (%==) SInt SString = SFalse+      (%==) SInt (SMaybe _) = SFalse+      (%==) SInt (SVec _ _) = SFalse+      (%==) SString SNat = SFalse+      (%==) SString SInt = SFalse+      (%==) SString SString = STrue+      (%==) SString (SMaybe _) = SFalse+      (%==) SString (SVec _ _) = SFalse+      (%==) (SMaybe _) SNat = SFalse+      (%==) (SMaybe _) SInt = SFalse+      (%==) (SMaybe _) SString = SFalse+      (%==) (SMaybe a) (SMaybe b) = ((%==) a) b+      (%==) (SMaybe _) (SVec _ _) = SFalse+      (%==) (SVec _ _) SNat = SFalse+      (%==) (SVec _ _) SInt = SFalse+      (%==) (SVec _ _) SString = SFalse+      (%==) (SVec _ _) (SMaybe _) = SFalse+      (%==) (SVec a a) (SVec b b) = ((%&&) (((%==) a) b)) (((%==) a) b)+    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)+      (%~) 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)+      (%~) 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)+      (%~) (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)+      (%~) (SVec a a) (SVec b b)+        = case ((,) (((%~) a) b)) (((%~) a) b) of+            (,) (Proved Refl) (Proved Refl) -> Proved Refl+            (,) (Disproved contra) _+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+            (,) _ (Disproved contra)+              -> Disproved (\ refl -> case refl of { Refl -> contra Refl })+    instance (SDecide Type, SDecide Nat) =>+             Data.Type.Equality.TestEquality (SRep :: Type -> Type) where+      Data.Type.Equality.testEquality = decideEquality+    instance (SDecide Type, SDecide Nat) =>+             Data.Type.Coercion.TestCoercion (SRep :: Type -> Type) where+      Data.Type.Coercion.testCoercion = decideCoercion+    instance (SOrd Type, SOrd Nat) => SOrd Type where+      sCompare ::+        forall (t1 :: Type) (t2 :: Type).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun Type ((~>) Type Ordering)+                                                 -> Type) t1) t2)+      sCompare SNat SNat+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            SNil+      sCompare SInt SInt+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            SNil+      sCompare SString SString+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            SNil+      sCompare+        (SMaybe (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SMaybe (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               SNil)+      sCompare+        (SVec (sA_0123456789876543210 :: Sing a_0123456789876543210)+              (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SVec (sB_0123456789876543210 :: Sing b_0123456789876543210)+              (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing ((singFun2 @(:@#@$)) SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               ((applySing+                   ((applySing ((singFun2 @(:@#@$)) SCons))+                      ((applySing+                          ((applySing ((singFun2 @CompareSym0) sCompare))+                             sA_0123456789876543210))+                         sB_0123456789876543210)))+                  SNil))+      sCompare SNat SInt = SLT+      sCompare SNat SString = SLT+      sCompare SNat (SMaybe _) = SLT+      sCompare SNat (SVec _ _) = SLT+      sCompare SInt SNat = SGT+      sCompare SInt SString = SLT+      sCompare SInt (SMaybe _) = SLT+      sCompare SInt (SVec _ _) = SLT+      sCompare SString SNat = SGT+      sCompare SString SInt = SGT+      sCompare SString (SMaybe _) = SLT+      sCompare SString (SVec _ _) = SLT+      sCompare (SMaybe _) SNat = SGT+      sCompare (SMaybe _) SInt = SGT+      sCompare (SMaybe _) SString = SGT+      sCompare (SMaybe _) (SVec _ _) = SLT+      sCompare (SVec _ _) SNat = SGT+      sCompare (SVec _ _) SInt = SGT+      sCompare (SVec _ _) SString = SGT+      sCompare (SVec _ _) (SMaybe _) = SGT+    instance (SShow Type, SShow Nat) => SShow Type where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Type) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) Type ((~>) Symbol Symbol))+                                                             -> Type) t1) t2) t3)+      sShowsPrec+        _+        SNat+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "Nat")))+            sA_0123456789876543210+      sShowsPrec+        _+        SInt+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "Int")))+            sA_0123456789876543210+      sShowsPrec+        _+        SString+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "String")))+            sA_0123456789876543210+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SMaybe (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "Maybe "))))+                   ((applySing+                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                          (sFromInteger (sing :: Sing 11))))+                      sArg_0123456789876543210))))+            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 SingI Nat where+      sing = SNat+    instance SingI Int where+      sing = SInt+    instance SingI String where+      sing = SString+    instance SingI n => SingI (Maybe (n :: Type)) where+      sing = SMaybe sing+    instance SingI (MaybeSym0 :: (~>) Type Type) where+      sing = (singFun1 @MaybeSym0) SMaybe+    instance (SingI n, SingI n) =>+             SingI (Vec (n :: Type) (n :: Nat)) where+      sing = (SVec sing) sing+    instance SingI (VecSym0 :: (~>) Type ((~>) Nat Type)) where+      sing = (singFun2 @VecSym0) SVec+    instance SingI d =>+             SingI (VecSym1 (d :: Type) :: (~>) Nat Type) where+      sing = (singFun1 @(VecSym1 (d :: Type))) (SVec (sing @d))
− tests/compile-and-dump/Singletons/T124.ghc86.template 
@@ -1,33 +0,0 @@-Singletons/T124.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo :: Bool -> ()-          foo True = ()-          foo False = () |]-  ======>-    foo :: Bool -> ()-    foo True = ()-    foo False = ()-    type FooSym1 (a0123456789876543210 :: Bool) =-        Foo a0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: (~>) Bool ()-      where-        FooSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210-    type family Foo (a :: Bool) :: () where-      Foo  'True = Tuple0Sym0-      Foo  'False = Tuple0Sym0-    sFoo :: forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: ())-    sFoo STrue = STuple0-    sFoo SFalse = STuple0-    instance SingI (FooSym0 :: (~>) Bool ()) where-      sing = (singFun1 @FooSym0) sFoo-Singletons/T124.hs:0:0:: Splicing expression-    sCases ''Bool [| b |] [| STuple0 |]-  ======>-    case b of-      SFalse -> STuple0-      STrue -> STuple0
+ tests/compile-and-dump/Singletons/T124.ghc88.template view
@@ -0,0 +1,33 @@+Singletons/T124.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo :: Bool -> ()+          foo True = ()+          foo False = () |]+  ======>+    foo :: Bool -> ()+    foo True = ()+    foo False = ()+    type FooSym1 (a0123456789876543210 :: Bool) =+        Foo a0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: (~>) Bool ()+      where+        FooSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 a0123456789876543210+    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210+    type family Foo (a :: Bool) :: () where+      Foo 'True = Tuple0Sym0+      Foo 'False = Tuple0Sym0+    sFoo :: forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: ())+    sFoo STrue = STuple0+    sFoo SFalse = STuple0+    instance SingI (FooSym0 :: (~>) Bool ()) where+      sing = (singFun1 @FooSym0) sFoo+Singletons/T124.hs:0:0:: Splicing expression+    sCases ''Bool [| b |] [| STuple0 |]+  ======>+    case b of+      SFalse -> STuple0+      STrue -> STuple0
− tests/compile-and-dump/Singletons/T136.ghc86.template 
@@ -1,171 +0,0 @@-Singletons/T136.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| instance Enum BiNat where-            succ [] = [True]-            succ (False : as) = True : as-            succ (True : as) = False : succ as-            pred [] = error "pred 0"-            pred (False : as) = True : pred as-            pred (True : as) = False : as-            toEnum i-              | i < 0 = error "negative toEnum"-              | i == 0 = []-              | otherwise = succ (toEnum (pred i))-            fromEnum [] = 0-            fromEnum (False : as) = 2 * fromEnum as-            fromEnum (True : as) = 1 + 2 * fromEnum as |]-  ======>-    instance Enum BiNat where-      succ [] = [True]-      succ (False : as) = (True : as)-      succ (True : as) = (False : succ as)-      pred [] = error "pred 0"-      pred (False : as) = (True : pred as)-      pred (True : as) = (False : as)-      toEnum i-        | (i < 0) = error "negative toEnum"-        | (i == 0) = []-        | otherwise = succ (toEnum (pred i))-      fromEnum [] = 0-      fromEnum (False : as) = (2 * fromEnum as)-      fromEnum (True : as) = (1 + (2 * fromEnum as))-    type family Succ_0123456789876543210 (a :: [Bool]) :: [Bool] where-      Succ_0123456789876543210 '[] = Apply (Apply (:@#@$) TrueSym0) '[]-      Succ_0123456789876543210 ( '(:)  'False as) = Apply (Apply (:@#@$) TrueSym0) as-      Succ_0123456789876543210 ( '(:)  'True as) = Apply (Apply (:@#@$) FalseSym0) (Apply SuccSym0 as)-    type Succ_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) =-        Succ_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Succ_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Succ_0123456789876543210Sym0KindInference) ())-    data Succ_0123456789876543210Sym0 :: (~>) [Bool] [Bool]-      where-        Succ_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                            arg. SameKind (Apply Succ_0123456789876543210Sym0 arg) (Succ_0123456789876543210Sym1 arg) =>-                                                     Succ_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Succ_0123456789876543210Sym0 a0123456789876543210 = Succ_0123456789876543210 a0123456789876543210-    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_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) =-        Pred_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Pred_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Pred_0123456789876543210Sym0KindInference) ())-    data Pred_0123456789876543210Sym0 :: (~>) [Bool] [Bool]-      where-        Pred_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                            arg. SameKind (Apply Pred_0123456789876543210Sym0 arg) (Pred_0123456789876543210Sym1 arg) =>-                                                     Pred_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Pred_0123456789876543210Sym0 a0123456789876543210 = Pred_0123456789876543210 a0123456789876543210-    type family Case_0123456789876543210 i arg_0123456789876543210 t where-      Case_0123456789876543210 i arg_0123456789876543210  'True = '[]-      Case_0123456789876543210 i arg_0123456789876543210  'False = Apply SuccSym0 (Apply ToEnumSym0 (Apply PredSym0 i))-    type family Case_0123456789876543210 i arg_0123456789876543210 t where-      Case_0123456789876543210 i arg_0123456789876543210  'True = Apply ErrorSym0 "negative toEnum"-      Case_0123456789876543210 i arg_0123456789876543210  'False = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (==@#@$) i) (FromInteger 0))-    type family Case_0123456789876543210 arg_0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 i = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (<@#@$) i) (FromInteger 0))-    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: [Bool] where-      ToEnum_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210-    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =-        ToEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat [Bool]-      where-        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210-    type family FromEnum_0123456789876543210 (a :: [Bool]) :: GHC.Types.Nat 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_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) =-        FromEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())-    data FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Types.Nat-      where-        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FromEnum_0123456789876543210Sym0 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-    instance SEnum [Bool] where-      sSucc ::-        forall (t :: [Bool]).-        Sing t-        -> Sing (Apply (SuccSym0 :: TyFun [Bool] [Bool]-                                    -> GHC.Types.Type) t)-      sPred ::-        forall (t :: [Bool]).-        Sing t-        -> Sing (Apply (PredSym0 :: TyFun [Bool] [Bool]-                                    -> GHC.Types.Type) t)-      sToEnum ::-        forall (t :: GHC.Types.Nat).-        Sing t-        -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Types.Nat [Bool]-                                      -> GHC.Types.Type) t)-      sFromEnum ::-        forall (t :: [Bool]).-        Sing t-        -> Sing (Apply (FromEnumSym0 :: TyFun [Bool] GHC.Types.Nat-                                        -> GHC.Types.Type) t)-      sSucc SNil-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue)) SNil-      sSucc (SCons SFalse (sAs :: Sing as))-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue)) sAs-      sSucc (SCons STrue (sAs :: Sing as))-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SFalse))-            ((applySing ((singFun1 @SuccSym0) sSucc)) sAs)-      sPred SNil = sError (sing :: Sing "pred 0")-      sPred (SCons SFalse (sAs :: Sing as))-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue))-            ((applySing ((singFun1 @PredSym0) sPred)) sAs)-      sPred (SCons STrue (sAs :: Sing as))-        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SFalse)) sAs-      sToEnum (sArg_0123456789876543210 :: Sing arg_0123456789876543210)-        = (case sArg_0123456789876543210 of {-             (sI :: Sing i)-               -> (case-                       (applySing ((applySing ((singFun2 @(<@#@$)) (%<))) sI))-                         (sFromInteger (sing :: Sing 0))-                   of-                     STrue -> sError (sing :: Sing "negative toEnum")-                     SFalse-                       -> (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))) ::-                            Sing (Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (==@#@$) i) (FromInteger 0)))) ::-                    Sing (Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (<@#@$) i) (FromInteger 0))) }) ::-            Sing (Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210)-      sFromEnum SNil = sFromInteger (sing :: Sing 0)-      sFromEnum (SCons SFalse (sAs :: Sing as))-        = (applySing-             ((applySing ((singFun2 @(*@#@$)) (%*)))-                (sFromInteger (sing :: Sing 2))))-            ((applySing ((singFun1 @FromEnumSym0) sFromEnum)) sAs)-      sFromEnum (SCons STrue (sAs :: Sing as))-        = (applySing-             ((applySing ((singFun2 @(+@#@$)) (%+)))-                (sFromInteger (sing :: Sing 1))))-            ((applySing-                ((applySing ((singFun2 @(*@#@$)) (%*)))-                   (sFromInteger (sing :: Sing 2))))-               ((applySing ((singFun1 @FromEnumSym0) sFromEnum)) sAs))
+ tests/compile-and-dump/Singletons/T136.ghc88.template view
@@ -0,0 +1,174 @@+Singletons/T136.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| instance Enum BiNat where+            succ [] = [True]+            succ (False : as) = True : as+            succ (True : as) = False : succ as+            pred [] = error "pred 0"+            pred (False : as) = True : pred as+            pred (True : as) = False : as+            toEnum i+              | i < 0 = error "negative toEnum"+              | i == 0 = []+              | otherwise = succ (toEnum (pred i))+            fromEnum [] = 0+            fromEnum (False : as) = 2 * fromEnum as+            fromEnum (True : as) = 1 + 2 * fromEnum as |]+  ======>+    instance Enum BiNat where+      succ [] = [True]+      succ (False : as) = (True : as)+      succ (True : as) = (False : succ as)+      pred [] = error "pred 0"+      pred (False : as) = (True : pred as)+      pred (True : as) = (False : as)+      toEnum i+        | (i < 0) = error "negative toEnum"+        | (i == 0) = []+        | otherwise = succ (toEnum (pred i))+      fromEnum [] = 0+      fromEnum (False : as) = (2 * fromEnum as)+      fromEnum (True : as) = (1 + (2 * fromEnum as))+    type family Succ_0123456789876543210 (a :: [Bool]) :: [Bool] where+      Succ_0123456789876543210 '[] = Apply (Apply (:@#@$) TrueSym0) '[]+      Succ_0123456789876543210 ('(:) 'False as) = Apply (Apply (:@#@$) TrueSym0) as+      Succ_0123456789876543210 ('(:) 'True as) = Apply (Apply (:@#@$) FalseSym0) (Apply SuccSym0 as)+    type Succ_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) =+        Succ_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Succ_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Succ_0123456789876543210Sym0KindInference) ())+    data Succ_0123456789876543210Sym0 :: (~>) [Bool] [Bool]+      where+        Succ_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                            arg. SameKind (Apply Succ_0123456789876543210Sym0 arg) (Succ_0123456789876543210Sym1 arg) =>+                                                     Succ_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Succ_0123456789876543210Sym0 a0123456789876543210 = Succ_0123456789876543210 a0123456789876543210+    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_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) =+        Pred_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Pred_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Pred_0123456789876543210Sym0KindInference) ())+    data Pred_0123456789876543210Sym0 :: (~>) [Bool] [Bool]+      where+        Pred_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                            arg. SameKind (Apply Pred_0123456789876543210Sym0 arg) (Pred_0123456789876543210Sym1 arg) =>+                                                     Pred_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Pred_0123456789876543210Sym0 a0123456789876543210 = Pred_0123456789876543210 a0123456789876543210+    type family Case_0123456789876543210 i arg_0123456789876543210 t where+      Case_0123456789876543210 i arg_0123456789876543210 'True = '[]+      Case_0123456789876543210 i arg_0123456789876543210 'False = Apply SuccSym0 (Apply ToEnumSym0 (Apply PredSym0 i))+    type family Case_0123456789876543210 i arg_0123456789876543210 t where+      Case_0123456789876543210 i arg_0123456789876543210 'True = Apply ErrorSym0 "negative toEnum"+      Case_0123456789876543210 i arg_0123456789876543210 'False = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (==@#@$) i) (FromInteger 0))+    type family Case_0123456789876543210 arg_0123456789876543210 t where+      Case_0123456789876543210 arg_0123456789876543210 i = Case_0123456789876543210 i arg_0123456789876543210 (Apply (Apply (<@#@$) i) (FromInteger 0))+    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: [Bool] where+      ToEnum_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 arg_0123456789876543210+    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =+        ToEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())+    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat [Bool]+      where+        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>+                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210+    type family FromEnum_0123456789876543210 (a :: [Bool]) :: GHC.Types.Nat 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_0123456789876543210Sym1 (a0123456789876543210 :: [Bool]) =+        FromEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())+    data FromEnum_0123456789876543210Sym0 :: (~>) [Bool] GHC.Types.Nat+      where+        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>+                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FromEnum_0123456789876543210Sym0 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+    instance SEnum [Bool] where+      sSucc ::+        forall (t :: [Bool]).+        Sing t+        -> Sing (Apply (SuccSym0 :: TyFun [Bool] [Bool]+                                    -> GHC.Types.Type) t)+      sPred ::+        forall (t :: [Bool]).+        Sing t+        -> Sing (Apply (PredSym0 :: TyFun [Bool] [Bool]+                                    -> GHC.Types.Type) t)+      sToEnum ::+        forall (t :: GHC.Types.Nat).+        Sing t+        -> Sing (Apply (ToEnumSym0 :: TyFun GHC.Types.Nat [Bool]+                                      -> GHC.Types.Type) t)+      sFromEnum ::+        forall (t :: [Bool]).+        Sing t+        -> Sing (Apply (FromEnumSym0 :: TyFun [Bool] GHC.Types.Nat+                                        -> GHC.Types.Type) t)+      sSucc SNil+        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue)) SNil+      sSucc (SCons SFalse (sAs :: Sing as))+        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue)) sAs+      sSucc (SCons STrue (sAs :: Sing as))+        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) SFalse))+            ((applySing ((singFun1 @SuccSym0) sSucc)) sAs)+      sPred SNil = sError (sing :: Sing "pred 0")+      sPred (SCons SFalse (sAs :: Sing as))+        = (applySing ((applySing ((singFun2 @(:@#@$)) SCons)) STrue))+            ((applySing ((singFun1 @PredSym0) sPred)) sAs)+      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)))) })+      sFromEnum SNil = sFromInteger (sing :: Sing 0)+      sFromEnum (SCons SFalse (sAs :: Sing as))+        = (applySing+             ((applySing ((singFun2 @(*@#@$)) (%*)))+                (sFromInteger (sing :: Sing 2))))+            ((applySing ((singFun1 @FromEnumSym0) sFromEnum)) sAs)+      sFromEnum (SCons STrue (sAs :: Sing as))+        = (applySing+             ((applySing ((singFun2 @(+@#@$)) (%+)))+                (sFromInteger (sing :: Sing 1))))+            ((applySing+                ((applySing ((singFun2 @(*@#@$)) (%*)))+                   (sFromInteger (sing :: Sing 2))))+               ((applySing ((singFun1 @FromEnumSym0) sFromEnum)) sAs))
− tests/compile-and-dump/Singletons/T136b.ghc86.template 
@@ -1,53 +0,0 @@-Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| class C a where-            meth :: a -> a |]-  ======>-    class C a where-      meth :: a -> a-    type MethSym1 (arg0123456789876543210 :: a0123456789876543210) =-        Meth arg0123456789876543210-    instance SuppressUnusedWarnings MethSym0 where-      suppressUnusedWarnings = snd (((,) MethSym0KindInference) ())-    data MethSym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 a0123456789876543210-      where-        MethSym0KindInference :: forall arg0123456789876543210-                                        arg. SameKind (Apply MethSym0 arg) (MethSym1 arg) =>-                                 MethSym0 arg0123456789876543210-    type instance Apply MethSym0 arg0123456789876543210 = Meth arg0123456789876543210-    class PC (a :: GHC.Types.Type) where-      type Meth (arg :: a) :: a-    class SC a where-      sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a)-    instance SC a => SingI (MethSym0 :: (~>) a a) where-      sing = (singFun1 @MethSym0) sMeth-Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| instance C Bool where-            meth = not |]-  ======>-    instance C Bool where-      meth = not-    type family Meth_0123456789876543210 (a :: Bool) :: Bool where-      Meth_0123456789876543210 a_0123456789876543210 = Apply NotSym0 a_0123456789876543210-    type Meth_0123456789876543210Sym1 (a0123456789876543210 :: Bool) =-        Meth_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Meth_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Meth_0123456789876543210Sym0KindInference) ())-    data Meth_0123456789876543210Sym0 :: (~>) Bool Bool-      where-        Meth_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                            arg. SameKind (Apply Meth_0123456789876543210Sym0 arg) (Meth_0123456789876543210Sym1 arg) =>-                                                     Meth_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Meth_0123456789876543210Sym0 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210-    instance PC Bool where-      type Meth a = Apply Meth_0123456789876543210Sym0 a-    instance SC Bool where-      sMeth ::-        forall (t :: Bool).-        Sing t-        -> Sing (Apply (MethSym0 :: TyFun Bool Bool -> GHC.Types.Type) t)-      sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing ((singFun1 @NotSym0) sNot)) sA_0123456789876543210
+ tests/compile-and-dump/Singletons/T136b.ghc88.template view
@@ -0,0 +1,53 @@+Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| class C a where+            meth :: a -> a |]+  ======>+    class C a where+      meth :: a -> a+    type MethSym1 (arg0123456789876543210 :: a0123456789876543210) =+        Meth arg0123456789876543210+    instance SuppressUnusedWarnings MethSym0 where+      suppressUnusedWarnings = snd (((,) MethSym0KindInference) ())+    data MethSym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 a0123456789876543210+      where+        MethSym0KindInference :: forall arg0123456789876543210+                                        arg. SameKind (Apply MethSym0 arg) (MethSym1 arg) =>+                                 MethSym0 arg0123456789876543210+    type instance Apply MethSym0 arg0123456789876543210 = Meth arg0123456789876543210+    class PC (a :: GHC.Types.Type) where+      type Meth (arg :: a) :: a+    class SC a where+      sMeth :: forall (t :: a). Sing t -> Sing (Apply MethSym0 t :: a)+    instance SC a => SingI (MethSym0 :: (~>) a a) where+      sing = (singFun1 @MethSym0) sMeth+Singletons/T136b.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| instance C Bool where+            meth = not |]+  ======>+    instance C Bool where+      meth = not+    type family Meth_0123456789876543210 (a :: Bool) :: Bool where+      Meth_0123456789876543210 a_0123456789876543210 = Apply NotSym0 a_0123456789876543210+    type Meth_0123456789876543210Sym1 (a0123456789876543210 :: Bool) =+        Meth_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Meth_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Meth_0123456789876543210Sym0KindInference) ())+    data Meth_0123456789876543210Sym0 :: (~>) Bool Bool+      where+        Meth_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                            arg. SameKind (Apply Meth_0123456789876543210Sym0 arg) (Meth_0123456789876543210Sym1 arg) =>+                                                     Meth_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Meth_0123456789876543210Sym0 a0123456789876543210 = Meth_0123456789876543210 a0123456789876543210+    instance PC Bool where+      type Meth a = Apply Meth_0123456789876543210Sym0 a+    instance SC Bool where+      sMeth ::+        forall (t :: Bool).+        Sing t+        -> Sing (Apply (MethSym0 :: TyFun Bool Bool -> GHC.Types.Type) t)+      sMeth (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing ((singFun1 @NotSym0) sNot)) sA_0123456789876543210
− tests/compile-and-dump/Singletons/T145.ghc86.template 
@@ -1,39 +0,0 @@-Singletons/T145.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| class Column (f :: Type -> Type) where-            col :: f a -> a -> Bool |]-  ======>-    class Column (f :: Type -> Type) where-      col :: f a -> a -> Bool-    type ColSym2 (arg0123456789876543210 :: f0123456789876543210 a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =-        Col arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (ColSym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) ColSym1KindInference) ())-    data ColSym1 (arg0123456789876543210 :: f0123456789876543210 a0123456789876543210) :: (~>) a0123456789876543210 Bool-      where-        ColSym1KindInference :: forall arg0123456789876543210-                                       arg0123456789876543210-                                       arg. SameKind (Apply (ColSym1 arg0123456789876543210) arg) (ColSym2 arg0123456789876543210 arg) =>-                                ColSym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (ColSym1 arg0123456789876543210) arg0123456789876543210 = Col arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings ColSym0 where-      suppressUnusedWarnings = snd (((,) ColSym0KindInference) ())-    data ColSym0 :: forall a0123456789876543210 f0123456789876543210.-                    (~>) (f0123456789876543210 a0123456789876543210) ((~>) a0123456789876543210 Bool)-      where-        ColSym0KindInference :: forall arg0123456789876543210-                                       arg. SameKind (Apply ColSym0 arg) (ColSym1 arg) =>-                                ColSym0 arg0123456789876543210-    type instance Apply ColSym0 arg0123456789876543210 = ColSym1 arg0123456789876543210-    class PColumn (f :: Type -> Type) where-      type Col (arg :: f a) (arg :: a) :: Bool-    class SColumn (f :: Type -> Type) where-      sCol ::-        forall a (t :: f a) (t :: a).-        Sing t -> Sing t -> Sing (Apply (Apply ColSym0 t) t :: Bool)-    instance SColumn f =>-             SingI (ColSym0 :: (~>) (f a) ((~>) a Bool)) where-      sing = (singFun2 @ColSym0) sCol-    instance (SColumn f, SingI d) =>-             SingI (ColSym1 (d :: f a) :: (~>) a Bool) where-      sing = (singFun1 @(ColSym1 (d :: f a))) (sCol (sing @d))
+ tests/compile-and-dump/Singletons/T145.ghc88.template view
@@ -0,0 +1,39 @@+Singletons/T145.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| class Column (f :: Type -> Type) where+            col :: f a -> a -> Bool |]+  ======>+    class Column (f :: Type -> Type) where+      col :: f a -> a -> Bool+    type ColSym2 (arg0123456789876543210 :: f0123456789876543210 a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =+        Col arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (ColSym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) ColSym1KindInference) ())+    data ColSym1 (arg0123456789876543210 :: f0123456789876543210 a0123456789876543210) :: (~>) a0123456789876543210 Bool+      where+        ColSym1KindInference :: forall arg0123456789876543210+                                       arg0123456789876543210+                                       arg. SameKind (Apply (ColSym1 arg0123456789876543210) arg) (ColSym2 arg0123456789876543210 arg) =>+                                ColSym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (ColSym1 arg0123456789876543210) arg0123456789876543210 = Col arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings ColSym0 where+      suppressUnusedWarnings = snd (((,) ColSym0KindInference) ())+    data ColSym0 :: forall f0123456789876543210 a0123456789876543210.+                    (~>) (f0123456789876543210 a0123456789876543210) ((~>) a0123456789876543210 Bool)+      where+        ColSym0KindInference :: forall arg0123456789876543210+                                       arg. SameKind (Apply ColSym0 arg) (ColSym1 arg) =>+                                ColSym0 arg0123456789876543210+    type instance Apply ColSym0 arg0123456789876543210 = ColSym1 arg0123456789876543210+    class PColumn (f :: Type -> Type) where+      type Col (arg :: f a) (arg :: a) :: Bool+    class SColumn (f :: Type -> Type) where+      sCol ::+        forall a (t :: f a) (t :: a).+        Sing t -> Sing t -> Sing (Apply (Apply ColSym0 t) t :: Bool)+    instance SColumn f =>+             SingI (ColSym0 :: (~>) (f a) ((~>) a Bool)) where+      sing = (singFun2 @ColSym0) sCol+    instance (SColumn f, SingI d) =>+             SingI (ColSym1 (d :: f a) :: (~>) a Bool) where+      sing = (singFun1 @(ColSym1 (d :: f a))) (sCol (sing @d))
− tests/compile-and-dump/Singletons/T153.ghc86.template 
+ tests/compile-and-dump/Singletons/T153.ghc88.template view
− tests/compile-and-dump/Singletons/T157.ghc86.template 
+ tests/compile-and-dump/Singletons/T157.ghc88.template view
− tests/compile-and-dump/Singletons/T159.ghc86.template 
@@ -1,245 +0,0 @@-Singletons/T159.hs:0:0:: Splicing declarations-    genSingletons [''T0, ''T1]-  ======>-    type ASym0 =  'A-    type BSym0 =  'B-    type CSym0 =  'C-    type DSym0 =  'D-    type ESym0 =  'E-    type FSym0 =  'F-    data instance Sing :: T0 -> GHC.Types.Type-      where-        SA :: Sing  'A-        SB :: Sing  'B-        SC :: Sing  'C-        SD :: Sing  'D-        SE :: Sing  'E-        SF :: Sing  'F-    type ST0 = (Sing :: T0 -> GHC.Types.Type)-    instance SingKind T0 where-      type Demote T0 = T0-      fromSing SA = A-      fromSing SB = B-      fromSing SC = C-      fromSing SD = D-      fromSing SE = E-      fromSing SF = F-      toSing A = SomeSing SA-      toSing B = SomeSing SB-      toSing C = SomeSing SC-      toSing D = SomeSing SD-      toSing E = SomeSing SE-      toSing F = SomeSing SF-    instance SingI  'A where-      sing = SA-    instance SingI  'B where-      sing = SB-    instance SingI  'C where-      sing = SC-    instance SingI  'D where-      sing = SD-    instance SingI  'E where-      sing = SE-    instance SingI  'F where-      sing = SF-    type N1Sym0 =  'N1-    type C1Sym2 (t0123456789876543210 :: T0) (t0123456789876543210 :: T1) =-         'C1 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (C1Sym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) C1Sym1KindInference) ())-    data C1Sym1 (t0123456789876543210 :: T0) :: (~>) T1 T1-      where-        C1Sym1KindInference :: forall t0123456789876543210-                                      t0123456789876543210-                                      arg. SameKind (Apply (C1Sym1 t0123456789876543210) arg) (C1Sym2 t0123456789876543210 arg) =>-                               C1Sym1 t0123456789876543210 t0123456789876543210-    type instance Apply (C1Sym1 t0123456789876543210) t0123456789876543210 =  'C1 t0123456789876543210 t0123456789876543210-    infixr 5 `C1Sym1`-    instance SuppressUnusedWarnings C1Sym0 where-      suppressUnusedWarnings = snd (((,) C1Sym0KindInference) ())-    data C1Sym0 :: (~>) T0 ((~>) T1 T1)-      where-        C1Sym0KindInference :: forall t0123456789876543210-                                      arg. SameKind (Apply C1Sym0 arg) (C1Sym1 arg) =>-                               C1Sym0 t0123456789876543210-    type instance Apply C1Sym0 t0123456789876543210 = C1Sym1 t0123456789876543210-    infixr 5 `C1Sym0`-    type (:&&@#@$$$) (t0123456789876543210 :: T0) (t0123456789876543210 :: T1) =-         '(:&&) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:&&@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::&&@#@$$###)) ())-    data (:&&@#@$$) (t0123456789876543210 :: T0) :: (~>) T1 T1-      where-        (::&&@#@$$###) :: forall t0123456789876543210-                                 t0123456789876543210-                                 arg. SameKind (Apply ((:&&@#@$$) t0123456789876543210) arg) ((:&&@#@$$$) t0123456789876543210 arg) =>-                          (:&&@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:&&@#@$$) t0123456789876543210) t0123456789876543210 =  '(:&&) t0123456789876543210 t0123456789876543210-    infixr 5 :&&@#@$$-    instance SuppressUnusedWarnings (:&&@#@$) where-      suppressUnusedWarnings = snd (((,) (::&&@#@$###)) ())-    data (:&&@#@$) :: (~>) T0 ((~>) T1 T1)-      where-        (::&&@#@$###) :: forall t0123456789876543210-                                arg. SameKind (Apply (:&&@#@$) arg) ((:&&@#@$$) arg) =>-                         (:&&@#@$) t0123456789876543210-    type instance Apply (:&&@#@$) t0123456789876543210 = (:&&@#@$$) t0123456789876543210-    infixr 5 :&&@#@$-    data instance Sing :: T1 -> GHC.Types.Type-      where-        SN1 :: Sing  'N1-        SC1 :: forall (n :: T0) (n :: T1).-               (Sing (n :: T0)) -> (Sing (n :: T1)) -> Sing ( 'C1 n n)-        (:%&&) :: forall (n :: T0) (n :: T1).-                  (Sing (n :: T0)) -> (Sing (n :: T1)) -> Sing ( '(:&&) n n)-    type ST1 = (Sing :: T1 -> GHC.Types.Type)-    instance SingKind T1 where-      type Demote T1 = T1-      fromSing SN1 = N1-      fromSing (SC1 b b) = (C1 (fromSing b)) (fromSing b)-      fromSing ((:%&&) b b) = ((:&&) (fromSing b)) (fromSing b)-      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) }-      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 :%&&-    instance SingI  'N1 where-      sing = SN1-    instance (SingI n, SingI n) =>-             SingI ( 'C1 (n :: T0) (n :: T1)) where-      sing = (SC1 sing) sing-    instance SingI (C1Sym0 :: (~>) T0 ((~>) T1 T1)) where-      sing = (singFun2 @C1Sym0) SC1-    instance SingI (TyCon2  'C1 :: (~>) T0 ((~>) T1 T1)) where-      sing = (singFun2 @(TyCon2  'C1)) SC1-    instance SingI d => SingI (C1Sym1 (d :: T0) :: (~>) T1 T1) where-      sing = (singFun1 @(C1Sym1 (d :: T0))) (SC1 (sing @d))-    instance SingI d =>-             SingI (TyCon1 ( 'C1 (d :: T0)) :: (~>) T1 T1) where-      sing = (singFun1 @(TyCon1 ( 'C1 (d :: T0)))) (SC1 (sing @d))-    instance (SingI n, SingI n) =>-             SingI ( '(:&&) (n :: T0) (n :: T1)) where-      sing = ((:%&&) sing) sing-    instance SingI ((:&&@#@$) :: (~>) T0 ((~>) T1 T1)) where-      sing = (singFun2 @(:&&@#@$)) (:%&&)-    instance SingI (TyCon2  '(:&&) :: (~>) T0 ((~>) T1 T1)) where-      sing = (singFun2 @(TyCon2  '(:&&))) (:%&&)-    instance SingI d =>-             SingI ((:&&@#@$$) (d :: T0) :: (~>) T1 T1) where-      sing = (singFun1 @((:&&@#@$$) (d :: T0))) ((:%&&) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ( '(:&&) (d :: T0)) :: (~>) T1 T1) where-      sing = (singFun1 @(TyCon1 ( '(:&&) (d :: T0)))) ((:%&&) (sing @d))-Singletons/T159.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| infixr 5 :||-          infixr 5 `C2`-          -          data T2 = N2 | C2 T0 T2 | T0 :|| T2 |]-  ======>-    data T2 = N2 | C2 T0 T2 | T0 :|| T2-    infixr 5 `C2`-    infixr 5 :||-    type N2Sym0 = N2-    type C2Sym2 (t0123456789876543210 :: T0) (t0123456789876543210 :: T2) =-        C2 t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (C2Sym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) C2Sym1KindInference) ())-    data C2Sym1 (t0123456789876543210 :: T0) :: (~>) T2 T2-      where-        C2Sym1KindInference :: forall t0123456789876543210-                                      t0123456789876543210-                                      arg. SameKind (Apply (C2Sym1 t0123456789876543210) arg) (C2Sym2 t0123456789876543210 arg) =>-                               C2Sym1 t0123456789876543210 t0123456789876543210-    type instance Apply (C2Sym1 t0123456789876543210) t0123456789876543210 = C2 t0123456789876543210 t0123456789876543210-    infixr 5 `C2Sym1`-    instance SuppressUnusedWarnings C2Sym0 where-      suppressUnusedWarnings = snd (((,) C2Sym0KindInference) ())-    data C2Sym0 :: (~>) T0 ((~>) T2 T2)-      where-        C2Sym0KindInference :: forall t0123456789876543210-                                      arg. SameKind (Apply C2Sym0 arg) (C2Sym1 arg) =>-                               C2Sym0 t0123456789876543210-    type instance Apply C2Sym0 t0123456789876543210 = C2Sym1 t0123456789876543210-    infixr 5 `C2Sym0`-    type (:||@#@$$$) (t0123456789876543210 :: T0) (t0123456789876543210 :: T2) =-        (:||) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:||@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::||@#@$$###)) ())-    data (:||@#@$$) (t0123456789876543210 :: T0) :: (~>) T2 T2-      where-        (::||@#@$$###) :: forall t0123456789876543210-                                 t0123456789876543210-                                 arg. SameKind (Apply ((:||@#@$$) t0123456789876543210) arg) ((:||@#@$$$) t0123456789876543210 arg) =>-                          (:||@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:||@#@$$) t0123456789876543210) t0123456789876543210 = (:||) t0123456789876543210 t0123456789876543210-    infixr 5 :||@#@$$-    instance SuppressUnusedWarnings (:||@#@$) where-      suppressUnusedWarnings = snd (((,) (::||@#@$###)) ())-    data (:||@#@$) :: (~>) T0 ((~>) T2 T2)-      where-        (::||@#@$###) :: forall t0123456789876543210-                                arg. SameKind (Apply (:||@#@$) arg) ((:||@#@$$) arg) =>-                         (:||@#@$) t0123456789876543210-    type instance Apply (:||@#@$) t0123456789876543210 = (:||@#@$$) t0123456789876543210-    infixr 5 :||@#@$-    infixr 5 `SC2`-    infixr 5 :%||-    data instance Sing :: T2 -> GHC.Types.Type-      where-        SN2 :: Sing N2-        SC2 :: forall (n :: T0) (n :: T2).-               (Sing (n :: T0)) -> (Sing (n :: T2)) -> Sing (C2 n n)-        (:%||) :: forall (n :: T0) (n :: T2).-                  (Sing (n :: T0)) -> (Sing (n :: T2)) -> Sing ((:||) n n)-    type ST2 = (Sing :: T2 -> GHC.Types.Type)-    instance SingKind T2 where-      type Demote T2 = T2-      fromSing SN2 = N2-      fromSing (SC2 b b) = (C2 (fromSing b)) (fromSing b)-      fromSing ((:%||) b b) = ((:||) (fromSing b)) (fromSing b)-      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) }-      toSing ((:||) (b :: Demote T0) (b :: Demote T2))-        = case-              ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2)-          of {-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%||) c) c) }-    instance SingI N2 where-      sing = SN2-    instance (SingI n, SingI n) => SingI (C2 (n :: T0) (n :: T2)) where-      sing = (SC2 sing) sing-    instance SingI (C2Sym0 :: (~>) T0 ((~>) T2 T2)) where-      sing = (singFun2 @C2Sym0) SC2-    instance SingI (TyCon2 C2 :: (~>) T0 ((~>) T2 T2)) where-      sing = (singFun2 @(TyCon2 C2)) SC2-    instance SingI d => SingI (C2Sym1 (d :: T0) :: (~>) T2 T2) where-      sing = (singFun1 @(C2Sym1 (d :: T0))) (SC2 (sing @d))-    instance SingI d =>-             SingI (TyCon1 (C2 (d :: T0)) :: (~>) T2 T2) where-      sing = (singFun1 @(TyCon1 (C2 (d :: T0)))) (SC2 (sing @d))-    instance (SingI n, SingI n) =>-             SingI ((:||) (n :: T0) (n :: T2)) where-      sing = ((:%||) sing) sing-    instance SingI ((:||@#@$) :: (~>) T0 ((~>) T2 T2)) where-      sing = (singFun2 @(:||@#@$)) (:%||)-    instance SingI (TyCon2 (:||) :: (~>) T0 ((~>) T2 T2)) where-      sing = (singFun2 @(TyCon2 (:||))) (:%||)-    instance SingI d =>-             SingI ((:||@#@$$) (d :: T0) :: (~>) T2 T2) where-      sing = (singFun1 @((:||@#@$$) (d :: T0))) ((:%||) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ((:||) (d :: T0)) :: (~>) T2 T2) where-      sing = (singFun1 @(TyCon1 ((:||) (d :: T0)))) ((:%||) (sing @d))
+ tests/compile-and-dump/Singletons/T159.ghc88.template view
@@ -0,0 +1,225 @@+Singletons/T159.hs:0:0:: Splicing declarations+    genSingletons [''T0, ''T1]+  ======>+    type ASym0 = 'A+    type BSym0 = 'B+    type CSym0 = 'C+    type DSym0 = 'D+    type ESym0 = 'E+    type FSym0 = 'F+    data ST0 :: T0 -> GHC.Types.Type+      where+        SA :: ST0 'A+        SB :: ST0 'B+        SC :: ST0 'C+        SD :: ST0 'D+        SE :: ST0 'E+        SF :: ST0 'F+    type instance Sing @T0 = ST0+    instance SingKind T0 where+      type Demote T0 = T0+      fromSing SA = A+      fromSing SB = B+      fromSing SC = C+      fromSing SD = D+      fromSing SE = E+      fromSing SF = F+      toSing A = SomeSing SA+      toSing B = SomeSing SB+      toSing C = SomeSing SC+      toSing D = SomeSing SD+      toSing E = SomeSing SE+      toSing F = SomeSing SF+    instance SingI 'A where+      sing = SA+    instance SingI 'B where+      sing = SB+    instance SingI 'C where+      sing = SC+    instance SingI 'D where+      sing = SD+    instance SingI 'E where+      sing = SE+    instance SingI 'F where+      sing = SF+    type N1Sym0 = 'N1+    type C1Sym2 (t0123456789876543210 :: T0) (t0123456789876543210 :: T1) =+        'C1 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (C1Sym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) C1Sym1KindInference) ())+    data C1Sym1 (t0123456789876543210 :: T0) :: (~>) T1 T1+      where+        C1Sym1KindInference :: forall t0123456789876543210+                                      t0123456789876543210+                                      arg. SameKind (Apply (C1Sym1 t0123456789876543210) arg) (C1Sym2 t0123456789876543210 arg) =>+                               C1Sym1 t0123456789876543210 t0123456789876543210+    type instance Apply (C1Sym1 t0123456789876543210) t0123456789876543210 = 'C1 t0123456789876543210 t0123456789876543210+    infixr 5 `C1Sym1`+    instance SuppressUnusedWarnings C1Sym0 where+      suppressUnusedWarnings = snd (((,) C1Sym0KindInference) ())+    data C1Sym0 :: (~>) T0 ((~>) T1 T1)+      where+        C1Sym0KindInference :: forall t0123456789876543210+                                      arg. SameKind (Apply C1Sym0 arg) (C1Sym1 arg) =>+                               C1Sym0 t0123456789876543210+    type instance Apply C1Sym0 t0123456789876543210 = C1Sym1 t0123456789876543210+    infixr 5 `C1Sym0`+    type (:&&@#@$$$) (t0123456789876543210 :: T0) (t0123456789876543210 :: T1) =+        '(:&&) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:&&@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::&&@#@$$###)) ())+    data (:&&@#@$$) (t0123456789876543210 :: T0) :: (~>) T1 T1+      where+        (::&&@#@$$###) :: forall t0123456789876543210+                                 t0123456789876543210+                                 arg. SameKind (Apply ((:&&@#@$$) t0123456789876543210) arg) ((:&&@#@$$$) t0123456789876543210 arg) =>+                          (:&&@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:&&@#@$$) t0123456789876543210) t0123456789876543210 = '(:&&) t0123456789876543210 t0123456789876543210+    infixr 5 :&&@#@$$+    instance SuppressUnusedWarnings (:&&@#@$) where+      suppressUnusedWarnings = snd (((,) (::&&@#@$###)) ())+    data (:&&@#@$) :: (~>) T0 ((~>) T1 T1)+      where+        (::&&@#@$###) :: forall t0123456789876543210+                                arg. SameKind (Apply (:&&@#@$) arg) ((:&&@#@$$) arg) =>+                         (:&&@#@$) t0123456789876543210+    type instance Apply (:&&@#@$) t0123456789876543210 = (:&&@#@$$) t0123456789876543210+    infixr 5 :&&@#@$+    data ST1 :: T1 -> GHC.Types.Type+      where+        SN1 :: ST1 'N1+        SC1 :: forall (n :: T0) (n :: T1).+               (Sing (n :: T0)) -> (Sing (n :: T1)) -> ST1 ('C1 n n)+        (:%&&) :: forall (n :: T0) (n :: T1).+                  (Sing (n :: T0)) -> (Sing (n :: T1)) -> ST1 ('(:&&) n n)+    type instance Sing @T1 = ST1+    instance SingKind T1 where+      type Demote T1 = T1+      fromSing SN1 = N1+      fromSing (SC1 b b) = (C1 (fromSing b)) (fromSing b)+      fromSing ((:%&&) b b) = ((:&&) (fromSing b)) (fromSing b)+      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) }+      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 :%&&+    instance SingI 'N1 where+      sing = SN1+    instance (SingI n, SingI n) =>+             SingI ('C1 (n :: T0) (n :: T1)) where+      sing = (SC1 sing) sing+    instance SingI (C1Sym0 :: (~>) T0 ((~>) T1 T1)) where+      sing = (singFun2 @C1Sym0) SC1+    instance SingI d => SingI (C1Sym1 (d :: T0) :: (~>) T1 T1) where+      sing = (singFun1 @(C1Sym1 (d :: T0))) (SC1 (sing @d))+    instance (SingI n, SingI n) =>+             SingI ('(:&&) (n :: T0) (n :: T1)) where+      sing = ((:%&&) sing) sing+    instance SingI ((:&&@#@$) :: (~>) T0 ((~>) T1 T1)) where+      sing = (singFun2 @(:&&@#@$)) (:%&&)+    instance SingI d =>+             SingI ((:&&@#@$$) (d :: T0) :: (~>) T1 T1) where+      sing = (singFun1 @((:&&@#@$$) (d :: T0))) ((:%&&) (sing @d))+Singletons/T159.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| infixr 5 :||+          infixr 5 `C2`+          +          data T2 = N2 | C2 T0 T2 | T0 :|| T2 |]+  ======>+    data T2 = N2 | C2 T0 T2 | T0 :|| T2+    infixr 5 `C2`+    infixr 5 :||+    type N2Sym0 = N2+    type C2Sym2 (t0123456789876543210 :: T0) (t0123456789876543210 :: T2) =+        C2 t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (C2Sym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) C2Sym1KindInference) ())+    data C2Sym1 (t0123456789876543210 :: T0) :: (~>) T2 T2+      where+        C2Sym1KindInference :: forall t0123456789876543210+                                      t0123456789876543210+                                      arg. SameKind (Apply (C2Sym1 t0123456789876543210) arg) (C2Sym2 t0123456789876543210 arg) =>+                               C2Sym1 t0123456789876543210 t0123456789876543210+    type instance Apply (C2Sym1 t0123456789876543210) t0123456789876543210 = C2 t0123456789876543210 t0123456789876543210+    infixr 5 `C2Sym1`+    instance SuppressUnusedWarnings C2Sym0 where+      suppressUnusedWarnings = snd (((,) C2Sym0KindInference) ())+    data C2Sym0 :: (~>) T0 ((~>) T2 T2)+      where+        C2Sym0KindInference :: forall t0123456789876543210+                                      arg. SameKind (Apply C2Sym0 arg) (C2Sym1 arg) =>+                               C2Sym0 t0123456789876543210+    type instance Apply C2Sym0 t0123456789876543210 = C2Sym1 t0123456789876543210+    infixr 5 `C2Sym0`+    type (:||@#@$$$) (t0123456789876543210 :: T0) (t0123456789876543210 :: T2) =+        (:||) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:||@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::||@#@$$###)) ())+    data (:||@#@$$) (t0123456789876543210 :: T0) :: (~>) T2 T2+      where+        (::||@#@$$###) :: forall t0123456789876543210+                                 t0123456789876543210+                                 arg. SameKind (Apply ((:||@#@$$) t0123456789876543210) arg) ((:||@#@$$$) t0123456789876543210 arg) =>+                          (:||@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:||@#@$$) t0123456789876543210) t0123456789876543210 = (:||) t0123456789876543210 t0123456789876543210+    infixr 5 :||@#@$$+    instance SuppressUnusedWarnings (:||@#@$) where+      suppressUnusedWarnings = snd (((,) (::||@#@$###)) ())+    data (:||@#@$) :: (~>) T0 ((~>) T2 T2)+      where+        (::||@#@$###) :: forall t0123456789876543210+                                arg. SameKind (Apply (:||@#@$) arg) ((:||@#@$$) arg) =>+                         (:||@#@$) t0123456789876543210+    type instance Apply (:||@#@$) t0123456789876543210 = (:||@#@$$) t0123456789876543210+    infixr 5 :||@#@$+    infixr 5 :%||+    infixr 5 `SC2`+    data ST2 :: T2 -> GHC.Types.Type+      where+        SN2 :: ST2 N2+        SC2 :: forall (n :: T0) (n :: T2).+               (Sing (n :: T0)) -> (Sing (n :: T2)) -> ST2 (C2 n n)+        (:%||) :: forall (n :: T0) (n :: T2).+                  (Sing (n :: T0)) -> (Sing (n :: T2)) -> ST2 ((:||) n n)+    type instance Sing @T2 = ST2+    instance SingKind T2 where+      type Demote T2 = T2+      fromSing SN2 = N2+      fromSing (SC2 b b) = (C2 (fromSing b)) (fromSing b)+      fromSing ((:%||) b b) = ((:||) (fromSing b)) (fromSing b)+      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) }+      toSing ((:||) (b :: Demote T0) (b :: Demote T2))+        = case+              ((,) (toSing b :: SomeSing T0)) (toSing b :: SomeSing T2)+          of {+            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%||) c) c) }+    instance SingI N2 where+      sing = SN2+    instance (SingI n, SingI n) => SingI (C2 (n :: T0) (n :: T2)) where+      sing = (SC2 sing) sing+    instance SingI (C2Sym0 :: (~>) T0 ((~>) T2 T2)) where+      sing = (singFun2 @C2Sym0) SC2+    instance SingI d => SingI (C2Sym1 (d :: T0) :: (~>) T2 T2) where+      sing = (singFun1 @(C2Sym1 (d :: T0))) (SC2 (sing @d))+    instance (SingI n, SingI n) =>+             SingI ((:||) (n :: T0) (n :: T2)) where+      sing = ((:%||) sing) sing+    instance SingI ((:||@#@$) :: (~>) T0 ((~>) T2 T2)) where+      sing = (singFun2 @(:||@#@$)) (:%||)+    instance SingI d =>+             SingI ((:||@#@$$) (d :: T0) :: (~>) T2 T2) where+      sing = (singFun1 @((:||@#@$$) (d :: T0))) ((:%||) (sing @d))
− tests/compile-and-dump/Singletons/T160.ghc86.template 
@@ -1,85 +0,0 @@-Singletons/T160.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo :: (Num a, Eq a) => a -> a-          foo x = if x == 0 then 1 else typeError $ ShowType x |]-  ======>-    foo :: (Num a, Eq a) => a -> a-    foo x = if (x == 0) then 1 else (typeError $ ShowType x)-    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 =-        Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 x where-      Let0123456789876543210Scrutinee_0123456789876543210 x = Apply (Apply (==@#@$) x) (FromInteger 0)-    type family Case_0123456789876543210 x t where-      Case_0123456789876543210 x  'True = FromInteger 1-      Case_0123456789876543210 x  'False = Apply (Apply ($@#@$) TypeErrorSym0) (Apply ShowTypeSym0 x)-    type FooSym1 (a0123456789876543210 :: a0123456789876543210) =-        Foo a0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: forall a0123456789876543210.-                    (~>) a0123456789876543210 a0123456789876543210-      where-        FooSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210-    type family Foo (a :: a) :: a where-      Foo x = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)-    sFoo ::-      forall a (t :: a).-      (SNum a, SEq a) => Sing t -> Sing (Apply FooSym0 t :: a)-    sFoo (sX :: Sing x)-      = let-          sScrutinee_0123456789876543210 ::-            Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)-          sScrutinee_0123456789876543210-            = (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sX))-                (sFromInteger (sing :: Sing 0))-        in  (case sScrutinee_0123456789876543210 of-               STrue -> sFromInteger (sing :: Sing 1)-               SFalse-                 -> (applySing ((applySing ((singFun2 @($@#@$)) (%$))) sTypeError))-                      ((applySing ((singFun1 @ShowTypeSym0) SShowType)) sX)) ::-              Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) :: a)-    instance (SNum a, SEq a) => SingI (FooSym0 :: (~>) a a) where-      sing = (singFun1 @FooSym0) sFoo--Singletons/T160.hs:0:0: error:-    • t-    • In the expression:-        (applySing ((applySing ((singFun2 @($@#@$)) (%$))) sTypeError))-          ((applySing ((singFun1 @ShowTypeSym0) SShowType)) sX)-      In a case alternative:-          SFalse-            -> (applySing ((applySing ((singFun2 @($@#@$)) (%$))) sTypeError))-                 ((applySing ((singFun1 @ShowTypeSym0) SShowType)) sX)-      In the expression:-          (case sScrutinee_0123456789876543210 of-             STrue -> sFromInteger (sing :: Sing 1)-             SFalse-               -> (applySing ((applySing ((singFun2 @($@#@$)) (%$))) sTypeError))-                    ((applySing ((singFun1 @ShowTypeSym0) SShowType)) sX)) ::-            Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) :: a)-  |-7 | $(singletons-  |   ^^^^^^^^^^...--Singletons/T160.hs:0:0: error:-    • 1-    • In the expression: Refl-      In an equation for ‘f’: f = Refl-   |-13 | f = Refl-   |     ^^^^
+ tests/compile-and-dump/Singletons/T160.ghc88.template view
@@ -0,0 +1,69 @@+Singletons/T160.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo :: (Num a, Eq a) => a -> a+          foo x = if x == 0 then 1 else typeError $ ShowType x |]+  ======>+    foo :: (Num a, Eq a) => a -> a+    foo x = if (x == 0) then 1 else (typeError $ ShowType x)+    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 =+        Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210+    type family Let0123456789876543210Scrutinee_0123456789876543210 x where+      Let0123456789876543210Scrutinee_0123456789876543210 x = Apply (Apply (==@#@$) x) (FromInteger 0)+    type family Case_0123456789876543210 x t where+      Case_0123456789876543210 x 'True = FromInteger 1+      Case_0123456789876543210 x 'False = Apply (Apply ($@#@$) TypeErrorSym0) (Apply ShowTypeSym0 x)+    type FooSym1 (a0123456789876543210 :: a0123456789876543210) =+        Foo a0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: forall a0123456789876543210.+                    (~>) a0123456789876543210 a0123456789876543210+      where+        FooSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 a0123456789876543210+    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210+    type family Foo (a :: a) :: a where+      Foo x = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)+    sFoo ::+      forall a (t :: a).+      (SNum a, SEq a) => Sing t -> Sing (Apply FooSym0 t :: a)+    sFoo (sX :: Sing x)+      = let+          sScrutinee_0123456789876543210 ::+            Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)+          sScrutinee_0123456789876543210+            = (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sX))+                (sFromInteger (sing :: Sing 0))+        in+          (id+             @(Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) :: a)))+            (case sScrutinee_0123456789876543210 of+               STrue -> sFromInteger (sing :: Sing 1)+               SFalse+                 -> (applySing+                       ((applySing ((singFun2 @($@#@$)) (%$)))+                          ((singFun1 @TypeErrorSym0) sTypeError)))+                      ((applySing ((singFun1 @ShowTypeSym0) SShowType)) sX))+    instance (SNum a, SEq a) => SingI (FooSym0 :: (~>) a a) where+      sing = (singFun1 @FooSym0) sFoo++Singletons/T160.hs:0:0: error:+    • 1+    • In the expression: Refl+      In an equation for ‘f’: f = Refl+   |+13 | f = Refl+   |     ^^^^
− tests/compile-and-dump/Singletons/T163.ghc86.template 
@@ -1,51 +0,0 @@-Singletons/T163.hs:0:0:: Splicing declarations-    singletons [d| data a + b = L a | R b |]-  ======>-    data (+) a b = L a | R b-    type LSym1 (t0123456789876543210 :: a0123456789876543210) =-        L t0123456789876543210-    instance SuppressUnusedWarnings LSym0 where-      suppressUnusedWarnings = snd (((,) LSym0KindInference) ())-    data LSym0 :: forall a0123456789876543210 b0123456789876543210.-                  (~>) a0123456789876543210 ((+) a0123456789876543210 b0123456789876543210)-      where-        LSym0KindInference :: forall t0123456789876543210-                                     arg. SameKind (Apply LSym0 arg) (LSym1 arg) =>-                              LSym0 t0123456789876543210-    type instance Apply LSym0 t0123456789876543210 = L t0123456789876543210-    type RSym1 (t0123456789876543210 :: b0123456789876543210) =-        R t0123456789876543210-    instance SuppressUnusedWarnings RSym0 where-      suppressUnusedWarnings = snd (((,) RSym0KindInference) ())-    data RSym0 :: forall a0123456789876543210 b0123456789876543210.-                  (~>) b0123456789876543210 ((+) a0123456789876543210 b0123456789876543210)-      where-        RSym0KindInference :: forall t0123456789876543210-                                     arg. SameKind (Apply RSym0 arg) (RSym1 arg) =>-                              RSym0 t0123456789876543210-    type instance Apply RSym0 t0123456789876543210 = R t0123456789876543210-    data instance Sing :: (+) a b -> GHC.Types.Type-      where-        SL :: forall a (n :: a). (Sing (n :: a)) -> Sing (L n)-        SR :: forall b (n :: b). (Sing (n :: b)) -> Sing (R n)-    type (%+) = (Sing :: (+) a b -> GHC.Types.Type)-    instance (SingKind a, SingKind b) => SingKind ((+) a b) where-      type Demote ((+) a b) = (+) (Demote a) (Demote b)-      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) }-      toSing (R (b :: Demote b))-        = case toSing b :: SomeSing b of { SomeSing c -> SomeSing (SR c) }-    instance SingI n => SingI (L (n :: a)) where-      sing = SL sing-    instance SingI (LSym0 :: (~>) a ((+) a b)) where-      sing = (singFun1 @LSym0) SL-    instance SingI (TyCon1 L :: (~>) a ((+) a b)) where-      sing = (singFun1 @(TyCon1 L)) SL-    instance SingI n => SingI (R (n :: b)) where-      sing = SR sing-    instance SingI (RSym0 :: (~>) b ((+) a b)) where-      sing = (singFun1 @RSym0) SR-    instance SingI (TyCon1 R :: (~>) b ((+) a b)) where-      sing = (singFun1 @(TyCon1 R)) SR
+ tests/compile-and-dump/Singletons/T163.ghc88.template view
@@ -0,0 +1,47 @@+Singletons/T163.hs:0:0:: Splicing declarations+    singletons [d| data a + b = L a | R b |]+  ======>+    data (+) a b = L a | R b+    type LSym1 (t0123456789876543210 :: a0123456789876543210) =+        L t0123456789876543210+    instance SuppressUnusedWarnings LSym0 where+      suppressUnusedWarnings = snd (((,) LSym0KindInference) ())+    data LSym0 :: forall a0123456789876543210 b0123456789876543210.+                  (~>) a0123456789876543210 ((+) a0123456789876543210 b0123456789876543210)+      where+        LSym0KindInference :: forall t0123456789876543210+                                     arg. SameKind (Apply LSym0 arg) (LSym1 arg) =>+                              LSym0 t0123456789876543210+    type instance Apply LSym0 t0123456789876543210 = L t0123456789876543210+    type RSym1 (t0123456789876543210 :: b0123456789876543210) =+        R t0123456789876543210+    instance SuppressUnusedWarnings RSym0 where+      suppressUnusedWarnings = snd (((,) RSym0KindInference) ())+    data RSym0 :: forall b0123456789876543210 a0123456789876543210.+                  (~>) b0123456789876543210 ((+) a0123456789876543210 b0123456789876543210)+      where+        RSym0KindInference :: forall t0123456789876543210+                                     arg. SameKind (Apply RSym0 arg) (RSym1 arg) =>+                              RSym0 t0123456789876543210+    type instance Apply RSym0 t0123456789876543210 = R t0123456789876543210+    data (%+) :: forall a b. (+) a b -> GHC.Types.Type+      where+        SL :: forall a (n :: a). (Sing (n :: a)) -> (%+) (L n)+        SR :: forall b (n :: b). (Sing (n :: b)) -> (%+) (R n)+    type instance Sing @((+) a b) = (%+)+    instance (SingKind a, SingKind b) => SingKind ((+) a b) where+      type Demote ((+) a b) = (+) (Demote a) (Demote b)+      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) }+      toSing (R (b :: Demote b))+        = case toSing b :: SomeSing b of { SomeSing c -> SomeSing (SR c) }+    instance SingI n => SingI (L (n :: a)) where+      sing = SL sing+    instance SingI (LSym0 :: (~>) a ((+) a b)) where+      sing = (singFun1 @LSym0) SL+    instance SingI n => SingI (R (n :: b)) where+      sing = SR sing+    instance SingI (RSym0 :: (~>) b ((+) a b)) where+      sing = (singFun1 @RSym0) SR
− tests/compile-and-dump/Singletons/T166.ghc86.template 
@@ -1,139 +0,0 @@-Singletons/T166.hs:(0,0)-(0,0): Splicing declarations-    singletonsOnly-      [d| class Foo a where-            foosPrec :: Nat -> a -> [Bool] -> [Bool]-            foo :: a -> [Bool]-            foo x s = foosPrec 0 x s |]-  ======>-    type FoosPrecSym3 (arg0123456789876543210 :: Nat) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: [Bool]) =-        FoosPrec arg0123456789876543210 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FoosPrecSym2KindInference) ())-    data FoosPrecSym2 (arg0123456789876543210 :: Nat) (arg0123456789876543210 :: a0123456789876543210) :: (~>) [Bool] [Bool]-      where-        FoosPrecSym2KindInference :: forall arg0123456789876543210-                                            arg0123456789876543210-                                            arg0123456789876543210-                                            arg. SameKind (Apply (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) arg) (FoosPrecSym3 arg0123456789876543210 arg0123456789876543210 arg) =>-                                     FoosPrecSym2 arg0123456789876543210 arg0123456789876543210 arg0123456789876543210-    type instance Apply (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) arg0123456789876543210 = FoosPrec arg0123456789876543210 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (FoosPrecSym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FoosPrecSym1KindInference) ())-    data FoosPrecSym1 (arg0123456789876543210 :: Nat) :: forall a0123456789876543210.-                                                         (~>) a0123456789876543210 ((~>) [Bool] [Bool])-      where-        FoosPrecSym1KindInference :: forall arg0123456789876543210-                                            arg0123456789876543210-                                            arg. SameKind (Apply (FoosPrecSym1 arg0123456789876543210) arg) (FoosPrecSym2 arg0123456789876543210 arg) =>-                                     FoosPrecSym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (FoosPrecSym1 arg0123456789876543210) arg0123456789876543210 = FoosPrecSym2 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings FoosPrecSym0 where-      suppressUnusedWarnings = snd (((,) FoosPrecSym0KindInference) ())-    data FoosPrecSym0 :: forall a0123456789876543210.-                         (~>) Nat ((~>) a0123456789876543210 ((~>) [Bool] [Bool]))-      where-        FoosPrecSym0KindInference :: forall arg0123456789876543210-                                            arg. SameKind (Apply FoosPrecSym0 arg) (FoosPrecSym1 arg) =>-                                     FoosPrecSym0 arg0123456789876543210-    type instance Apply FoosPrecSym0 arg0123456789876543210 = FoosPrecSym1 arg0123456789876543210-    type FooSym1 (arg0123456789876543210 :: a0123456789876543210) =-        Foo arg0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: forall a0123456789876543210.-                    (~>) a0123456789876543210 [Bool]-      where-        FooSym0KindInference :: forall arg0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 arg0123456789876543210-    type instance Apply FooSym0 arg0123456789876543210 = Foo arg0123456789876543210-    type family Lambda_0123456789876543210 x t where-      Lambda_0123456789876543210 x s = Apply (Apply (Apply FoosPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 0)) x) s-    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type family Foo_0123456789876543210 (a :: a) :: [Bool] where-      Foo_0123456789876543210 x = Apply Lambda_0123456789876543210Sym0 x-    type Foo_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Foo_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Foo_0123456789876543210Sym0KindInference) ())-    data Foo_0123456789876543210Sym0 :: forall a0123456789876543210.-                                        (~>) a0123456789876543210 [Bool]-      where-        Foo_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                           arg. SameKind (Apply Foo_0123456789876543210Sym0 arg) (Foo_0123456789876543210Sym1 arg) =>-                                                    Foo_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Foo_0123456789876543210Sym0 a0123456789876543210 = Foo_0123456789876543210 a0123456789876543210-    class PFoo (a :: GHC.Types.Type) where-      type FoosPrec (arg :: Nat) (arg :: a) (arg :: [Bool]) :: [Bool]-      type Foo (arg :: a) :: [Bool]-      type Foo a = Apply Foo_0123456789876543210Sym0 a-    class SFoo a where-      sFoosPrec ::-        forall (t :: Nat) (t :: a) (t :: [Bool]).-        Sing t-        -> Sing t-           -> Sing t-              -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])-      sFoo :: forall (t :: a). Sing t -> Sing (Apply FooSym0 t :: [Bool])-      default sFoo ::-                forall (t :: a).-                (Apply FooSym0 t :: [Bool])-                ~ Apply Foo_0123456789876543210Sym0 t =>-                Sing t -> Sing (Apply FooSym0 t :: [Bool])-      sFoo (sX :: Sing x)-        = (singFun1 @(Apply Lambda_0123456789876543210Sym0 x))-            (\ sS-               -> case sS of {-                    (_ :: Sing s)-                      -> (applySing-                            ((applySing-                                ((applySing ((singFun3 @FoosPrecSym0) sFoosPrec))-                                   (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0))))-                               sX))-                           sS })-    instance SFoo a =>-             SingI (FoosPrecSym0 :: (~>) Nat ((~>) a ((~>) [Bool] [Bool]))) where-      sing = (singFun3 @FoosPrecSym0) sFoosPrec-    instance (SFoo a, SingI d) =>-             SingI (FoosPrecSym1 (d :: Nat) :: (~>) a ((~>) [Bool] [Bool])) where-      sing = (singFun2 @(FoosPrecSym1 (d :: Nat))) (sFoosPrec (sing @d))-    instance (SFoo a, SingI d, SingI d) =>-             SingI (FoosPrecSym2 (d :: Nat) (d :: a) :: (~>) [Bool] [Bool]) where-      sing-        = (singFun1 @(FoosPrecSym2 (d :: Nat) (d :: a)))-            ((sFoosPrec (sing @d)) (sing @d))-    instance SFoo a => SingI (FooSym0 :: (~>) a [Bool]) where-      sing = (singFun1 @FooSym0) sFoo--Singletons/T166.hs:0:0: error:-    • Expecting one more argument to ‘Apply Lambda_0123456789876543210Sym0 x’-      Expected kind ‘[Bool]’,-        but ‘Apply Lambda_0123456789876543210Sym0 x’ has kind ‘TyFun-                                                                 [Bool] [Bool]-                                                               -> Type’-    • In the type ‘Apply Lambda_0123456789876543210Sym0 x’-      In the type family declaration for ‘Foo_0123456789876543210’-   |-14 | $(singletonsOnly [d|-   |   ^^^^^^^^^^^^^^^^^^...
+ tests/compile-and-dump/Singletons/T166.ghc88.template view
@@ -0,0 +1,139 @@+Singletons/T166.hs:(0,0)-(0,0): Splicing declarations+    singletonsOnly+      [d| class Foo a where+            foosPrec :: Nat -> a -> [Bool] -> [Bool]+            foo :: a -> [Bool]+            foo x s = foosPrec 0 x s |]+  ======>+    type FoosPrecSym3 (arg0123456789876543210 :: Nat) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: [Bool]) =+        FoosPrec arg0123456789876543210 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FoosPrecSym2KindInference) ())+    data FoosPrecSym2 (arg0123456789876543210 :: Nat) (arg0123456789876543210 :: a0123456789876543210) :: (~>) [Bool] [Bool]+      where+        FoosPrecSym2KindInference :: forall arg0123456789876543210+                                            arg0123456789876543210+                                            arg0123456789876543210+                                            arg. SameKind (Apply (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) arg) (FoosPrecSym3 arg0123456789876543210 arg0123456789876543210 arg) =>+                                     FoosPrecSym2 arg0123456789876543210 arg0123456789876543210 arg0123456789876543210+    type instance Apply (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) arg0123456789876543210 = FoosPrec arg0123456789876543210 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (FoosPrecSym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FoosPrecSym1KindInference) ())+    data FoosPrecSym1 (arg0123456789876543210 :: Nat) :: forall a0123456789876543210.+                                                         (~>) a0123456789876543210 ((~>) [Bool] [Bool])+      where+        FoosPrecSym1KindInference :: forall arg0123456789876543210+                                            arg0123456789876543210+                                            arg. SameKind (Apply (FoosPrecSym1 arg0123456789876543210) arg) (FoosPrecSym2 arg0123456789876543210 arg) =>+                                     FoosPrecSym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (FoosPrecSym1 arg0123456789876543210) arg0123456789876543210 = FoosPrecSym2 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings FoosPrecSym0 where+      suppressUnusedWarnings = snd (((,) FoosPrecSym0KindInference) ())+    data FoosPrecSym0 :: forall a0123456789876543210.+                         (~>) Nat ((~>) a0123456789876543210 ((~>) [Bool] [Bool]))+      where+        FoosPrecSym0KindInference :: forall arg0123456789876543210+                                            arg. SameKind (Apply FoosPrecSym0 arg) (FoosPrecSym1 arg) =>+                                     FoosPrecSym0 arg0123456789876543210+    type instance Apply FoosPrecSym0 arg0123456789876543210 = FoosPrecSym1 arg0123456789876543210+    type FooSym1 (arg0123456789876543210 :: a0123456789876543210) =+        Foo arg0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: forall a0123456789876543210.+                    (~>) a0123456789876543210 [Bool]+      where+        FooSym0KindInference :: forall arg0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 arg0123456789876543210+    type instance Apply FooSym0 arg0123456789876543210 = Foo arg0123456789876543210+    type family Lambda_0123456789876543210 x t where+      Lambda_0123456789876543210 x s = Apply (Apply (Apply FoosPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 0)) x) s+    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Foo_0123456789876543210 (a :: a) :: [Bool] where+      Foo_0123456789876543210 x = Apply Lambda_0123456789876543210Sym0 x+    type Foo_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Foo_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Foo_0123456789876543210Sym0KindInference) ())+    data Foo_0123456789876543210Sym0 :: forall a0123456789876543210.+                                        (~>) a0123456789876543210 [Bool]+      where+        Foo_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                           arg. SameKind (Apply Foo_0123456789876543210Sym0 arg) (Foo_0123456789876543210Sym1 arg) =>+                                                    Foo_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Foo_0123456789876543210Sym0 a0123456789876543210 = Foo_0123456789876543210 a0123456789876543210+    class PFoo (a :: GHC.Types.Type) where+      type FoosPrec (arg :: Nat) (arg :: a) (arg :: [Bool]) :: [Bool]+      type Foo (arg :: a) :: [Bool]+      type Foo a = Apply Foo_0123456789876543210Sym0 a+    class SFoo a where+      sFoosPrec ::+        forall (t :: Nat) (t :: a) (t :: [Bool]).+        Sing t+        -> Sing t+           -> Sing t+              -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])+      sFoo :: forall (t :: a). Sing t -> Sing (Apply FooSym0 t :: [Bool])+      default sFoo ::+                forall (t :: a).+                ((Apply FooSym0 t :: [Bool])+                 ~ Apply Foo_0123456789876543210Sym0 t) =>+                Sing t -> Sing (Apply FooSym0 t :: [Bool])+      sFoo (sX :: Sing x)+        = (singFun1 @(Apply Lambda_0123456789876543210Sym0 x))+            (\ sS+               -> case sS of {+                    (_ :: Sing s)+                      -> (applySing+                            ((applySing+                                ((applySing ((singFun3 @FoosPrecSym0) sFoosPrec))+                                   (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0))))+                               sX))+                           sS })+    instance SFoo a =>+             SingI (FoosPrecSym0 :: (~>) Nat ((~>) a ((~>) [Bool] [Bool]))) where+      sing = (singFun3 @FoosPrecSym0) sFoosPrec+    instance (SFoo a, SingI d) =>+             SingI (FoosPrecSym1 (d :: Nat) :: (~>) a ((~>) [Bool] [Bool])) where+      sing = (singFun2 @(FoosPrecSym1 (d :: Nat))) (sFoosPrec (sing @d))+    instance (SFoo a, SingI d, SingI d) =>+             SingI (FoosPrecSym2 (d :: Nat) (d :: a) :: (~>) [Bool] [Bool]) where+      sing+        = (singFun1 @(FoosPrecSym2 (d :: Nat) (d :: a)))+            ((sFoosPrec (sing @d)) (sing @d))+    instance SFoo a => SingI (FooSym0 :: (~>) a [Bool]) where+      sing = (singFun1 @FooSym0) sFoo++Singletons/T166.hs:0:0: error:+    • Expecting one more argument to ‘Apply Lambda_0123456789876543210Sym0 x’+      Expected kind ‘[Bool]’,+        but ‘Apply Lambda_0123456789876543210Sym0 x’ has kind ‘TyFun+                                                                 [Bool] [Bool]+                                                               -> Type’+    • In the type ‘Apply Lambda_0123456789876543210Sym0 x’+      In the type family declaration for ‘Foo_0123456789876543210’+   |+14 | $(singletonsOnly [d|+   |   ^^^^^^^^^^^^^^^^^^...
− tests/compile-and-dump/Singletons/T167.ghc86.template 
@@ -1,178 +0,0 @@-Singletons/T167.hs:(0,0)-(0,0): Splicing declarations-    singletonsOnly-      [d| class Foo a where-            foosPrec :: Nat -> a -> DiffList-            fooList :: a -> DiffList-            fooList = undefined-          -          instance Foo a => Foo [a] where-            foosPrec _ = fooList |]-  ======>-    type FoosPrecSym3 (arg0123456789876543210 :: Nat) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: [Bool]) =-        FoosPrec arg0123456789876543210 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FoosPrecSym2KindInference) ())-    data FoosPrecSym2 (arg0123456789876543210 :: Nat) (arg0123456789876543210 :: a0123456789876543210) :: (~>) [Bool] [Bool]-      where-        FoosPrecSym2KindInference :: forall arg0123456789876543210-                                            arg0123456789876543210-                                            arg0123456789876543210-                                            arg. SameKind (Apply (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) arg) (FoosPrecSym3 arg0123456789876543210 arg0123456789876543210 arg) =>-                                     FoosPrecSym2 arg0123456789876543210 arg0123456789876543210 arg0123456789876543210-    type instance Apply (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) arg0123456789876543210 = FoosPrec arg0123456789876543210 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (FoosPrecSym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FoosPrecSym1KindInference) ())-    data FoosPrecSym1 (arg0123456789876543210 :: Nat) :: forall a0123456789876543210.-                                                         (~>) a0123456789876543210 ((~>) [Bool] [Bool])-      where-        FoosPrecSym1KindInference :: forall arg0123456789876543210-                                            arg0123456789876543210-                                            arg. SameKind (Apply (FoosPrecSym1 arg0123456789876543210) arg) (FoosPrecSym2 arg0123456789876543210 arg) =>-                                     FoosPrecSym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (FoosPrecSym1 arg0123456789876543210) arg0123456789876543210 = FoosPrecSym2 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings FoosPrecSym0 where-      suppressUnusedWarnings = snd (((,) FoosPrecSym0KindInference) ())-    data FoosPrecSym0 :: forall a0123456789876543210.-                         (~>) Nat ((~>) a0123456789876543210 ((~>) [Bool] [Bool]))-      where-        FoosPrecSym0KindInference :: forall arg0123456789876543210-                                            arg. SameKind (Apply FoosPrecSym0 arg) (FoosPrecSym1 arg) =>-                                     FoosPrecSym0 arg0123456789876543210-    type instance Apply FoosPrecSym0 arg0123456789876543210 = FoosPrecSym1 arg0123456789876543210-    type FooListSym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: [Bool]) =-        FooList arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (FooListSym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) FooListSym1KindInference) ())-    data FooListSym1 (arg0123456789876543210 :: a0123456789876543210) :: (~>) [Bool] [Bool]-      where-        FooListSym1KindInference :: forall arg0123456789876543210-                                           arg0123456789876543210-                                           arg. SameKind (Apply (FooListSym1 arg0123456789876543210) arg) (FooListSym2 arg0123456789876543210 arg) =>-                                    FooListSym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (FooListSym1 arg0123456789876543210) arg0123456789876543210 = FooList arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings FooListSym0 where-      suppressUnusedWarnings = snd (((,) FooListSym0KindInference) ())-    data FooListSym0 :: forall a0123456789876543210.-                        (~>) a0123456789876543210 ((~>) [Bool] [Bool])-      where-        FooListSym0KindInference :: forall arg0123456789876543210-                                           arg. SameKind (Apply FooListSym0 arg) (FooListSym1 arg) =>-                                    FooListSym0 arg0123456789876543210-    type instance Apply FooListSym0 arg0123456789876543210 = FooListSym1 arg0123456789876543210-    type family FooList_0123456789876543210 (a :: a) (a :: [Bool]) :: [Bool] where-      FooList_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply UndefinedSym0 a_0123456789876543210) a_0123456789876543210-    type FooList_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: [Bool]) =-        FooList_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (FooList_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) FooList_0123456789876543210Sym1KindInference) ())-    data FooList_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) [Bool] [Bool]-      where-        FooList_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FooList_0123456789876543210Sym0KindInference) ())-    data FooList_0123456789876543210Sym0 :: forall a0123456789876543210.-                                            (~>) a0123456789876543210 ((~>) [Bool] [Bool])-      where-        FooList_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply FooList_0123456789876543210Sym0 arg) (FooList_0123456789876543210Sym1 arg) =>-                                                        FooList_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FooList_0123456789876543210Sym0 a0123456789876543210 = FooList_0123456789876543210Sym1 a0123456789876543210-    class PFoo (a :: GHC.Types.Type) where-      type FoosPrec (arg :: Nat) (arg :: a) (arg :: [Bool]) :: [Bool]-      type FooList (arg :: a) (arg :: [Bool]) :: [Bool]-      type FooList a a = Apply (Apply FooList_0123456789876543210Sym0 a) a-    type family FoosPrec_0123456789876543210 (a :: Nat) (a :: [a]) (a :: [Bool]) :: [Bool] where-      FoosPrec_0123456789876543210 _ a_0123456789876543210 a_0123456789876543210 = Apply (Apply FooListSym0 a_0123456789876543210) a_0123456789876543210-    type FoosPrec_0123456789876543210Sym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [a0123456789876543210]) (a0123456789876543210 :: [Bool]) =-        FoosPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) FoosPrec_0123456789876543210Sym2KindInference) ())-    data FoosPrec_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [a0123456789876543210]) :: (~>) [Bool] [Bool]-      where-        FoosPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) FoosPrec_0123456789876543210Sym1KindInference) ())-    data FoosPrec_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: forall a0123456789876543210.-                                                                           (~>) [a0123456789876543210] ((~>) [Bool] [Bool])-      where-        FoosPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FoosPrec_0123456789876543210Sym0KindInference) ())-    data FoosPrec_0123456789876543210Sym0 :: forall a0123456789876543210.-                                             (~>) Nat ((~>) [a0123456789876543210] ((~>) [Bool] [Bool]))-      where-        FoosPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply FoosPrec_0123456789876543210Sym0 arg) (FoosPrec_0123456789876543210Sym1 arg) =>-                                                         FoosPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FoosPrec_0123456789876543210Sym0 a0123456789876543210 = FoosPrec_0123456789876543210Sym1 a0123456789876543210-    instance PFoo [a] where-      type FoosPrec a a a = Apply (Apply (Apply FoosPrec_0123456789876543210Sym0 a) a) a-    class SFoo a where-      sFoosPrec ::-        forall (t :: Nat) (t :: a) (t :: [Bool]).-        Sing t-        -> Sing t-           -> Sing t-              -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])-      sFooList ::-        forall (t :: a) (t :: [Bool]).-        Sing t -> Sing t -> Sing (Apply (Apply FooListSym0 t) t :: [Bool])-      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])-      sFooList-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (sUndefined sA_0123456789876543210) sA_0123456789876543210-    instance SFoo a => SFoo [a] where-      sFoosPrec ::-        forall (t :: Nat) (t :: [a]) (t :: [Bool]).-        Sing t-        -> Sing t-           -> Sing t-              -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])-      sFoosPrec-        _-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @FooListSym0) sFooList))-                sA_0123456789876543210))-            sA_0123456789876543210-    instance SFoo a =>-             SingI (FoosPrecSym0 :: (~>) Nat ((~>) a ((~>) [Bool] [Bool]))) where-      sing = (singFun3 @FoosPrecSym0) sFoosPrec-    instance (SFoo a, SingI d) =>-             SingI (FoosPrecSym1 (d :: Nat) :: (~>) a ((~>) [Bool] [Bool])) where-      sing = (singFun2 @(FoosPrecSym1 (d :: Nat))) (sFoosPrec (sing @d))-    instance (SFoo a, SingI d, SingI d) =>-             SingI (FoosPrecSym2 (d :: Nat) (d :: a) :: (~>) [Bool] [Bool]) where-      sing-        = (singFun1 @(FoosPrecSym2 (d :: Nat) (d :: a)))-            ((sFoosPrec (sing @d)) (sing @d))-    instance SFoo a =>-             SingI (FooListSym0 :: (~>) a ((~>) [Bool] [Bool])) where-      sing = (singFun2 @FooListSym0) sFooList-    instance (SFoo a, SingI d) =>-             SingI (FooListSym1 (d :: a) :: (~>) [Bool] [Bool]) where-      sing = (singFun1 @(FooListSym1 (d :: a))) (sFooList (sing @d))
+ tests/compile-and-dump/Singletons/T167.ghc88.template view
@@ -0,0 +1,178 @@+Singletons/T167.hs:(0,0)-(0,0): Splicing declarations+    singletonsOnly+      [d| class Foo a where+            foosPrec :: Nat -> a -> DiffList+            fooList :: a -> DiffList+            fooList = undefined+          +          instance Foo a => Foo [a] where+            foosPrec _ = fooList |]+  ======>+    type FoosPrecSym3 (arg0123456789876543210 :: Nat) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: [Bool]) =+        FoosPrec arg0123456789876543210 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FoosPrecSym2KindInference) ())+    data FoosPrecSym2 (arg0123456789876543210 :: Nat) (arg0123456789876543210 :: a0123456789876543210) :: (~>) [Bool] [Bool]+      where+        FoosPrecSym2KindInference :: forall arg0123456789876543210+                                            arg0123456789876543210+                                            arg0123456789876543210+                                            arg. SameKind (Apply (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) arg) (FoosPrecSym3 arg0123456789876543210 arg0123456789876543210 arg) =>+                                     FoosPrecSym2 arg0123456789876543210 arg0123456789876543210 arg0123456789876543210+    type instance Apply (FoosPrecSym2 arg0123456789876543210 arg0123456789876543210) arg0123456789876543210 = FoosPrec arg0123456789876543210 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (FoosPrecSym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FoosPrecSym1KindInference) ())+    data FoosPrecSym1 (arg0123456789876543210 :: Nat) :: forall a0123456789876543210.+                                                         (~>) a0123456789876543210 ((~>) [Bool] [Bool])+      where+        FoosPrecSym1KindInference :: forall arg0123456789876543210+                                            arg0123456789876543210+                                            arg. SameKind (Apply (FoosPrecSym1 arg0123456789876543210) arg) (FoosPrecSym2 arg0123456789876543210 arg) =>+                                     FoosPrecSym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (FoosPrecSym1 arg0123456789876543210) arg0123456789876543210 = FoosPrecSym2 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings FoosPrecSym0 where+      suppressUnusedWarnings = snd (((,) FoosPrecSym0KindInference) ())+    data FoosPrecSym0 :: forall a0123456789876543210.+                         (~>) Nat ((~>) a0123456789876543210 ((~>) [Bool] [Bool]))+      where+        FoosPrecSym0KindInference :: forall arg0123456789876543210+                                            arg. SameKind (Apply FoosPrecSym0 arg) (FoosPrecSym1 arg) =>+                                     FoosPrecSym0 arg0123456789876543210+    type instance Apply FoosPrecSym0 arg0123456789876543210 = FoosPrecSym1 arg0123456789876543210+    type FooListSym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: [Bool]) =+        FooList arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (FooListSym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FooListSym1KindInference) ())+    data FooListSym1 (arg0123456789876543210 :: a0123456789876543210) :: (~>) [Bool] [Bool]+      where+        FooListSym1KindInference :: forall arg0123456789876543210+                                           arg0123456789876543210+                                           arg. SameKind (Apply (FooListSym1 arg0123456789876543210) arg) (FooListSym2 arg0123456789876543210 arg) =>+                                    FooListSym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (FooListSym1 arg0123456789876543210) arg0123456789876543210 = FooList arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings FooListSym0 where+      suppressUnusedWarnings = snd (((,) FooListSym0KindInference) ())+    data FooListSym0 :: forall a0123456789876543210.+                        (~>) a0123456789876543210 ((~>) [Bool] [Bool])+      where+        FooListSym0KindInference :: forall arg0123456789876543210+                                           arg. SameKind (Apply FooListSym0 arg) (FooListSym1 arg) =>+                                    FooListSym0 arg0123456789876543210+    type instance Apply FooListSym0 arg0123456789876543210 = FooListSym1 arg0123456789876543210+    type family FooList_0123456789876543210 (a :: a) (a :: [Bool]) :: [Bool] where+      FooList_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply UndefinedSym0 a_0123456789876543210) a_0123456789876543210+    type FooList_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: [Bool]) =+        FooList_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (FooList_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) FooList_0123456789876543210Sym1KindInference) ())+    data FooList_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: (~>) [Bool] [Bool]+      where+        FooList_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FooList_0123456789876543210Sym0KindInference) ())+    data FooList_0123456789876543210Sym0 :: forall a0123456789876543210.+                                            (~>) a0123456789876543210 ((~>) [Bool] [Bool])+      where+        FooList_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply FooList_0123456789876543210Sym0 arg) (FooList_0123456789876543210Sym1 arg) =>+                                                        FooList_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FooList_0123456789876543210Sym0 a0123456789876543210 = FooList_0123456789876543210Sym1 a0123456789876543210+    class PFoo (a :: GHC.Types.Type) where+      type FoosPrec (arg :: Nat) (arg :: a) (arg :: [Bool]) :: [Bool]+      type FooList (arg :: a) (arg :: [Bool]) :: [Bool]+      type FooList a a = Apply (Apply FooList_0123456789876543210Sym0 a) a+    type family FoosPrec_0123456789876543210 (a :: Nat) (a :: [a]) (a :: [Bool]) :: [Bool] where+      FoosPrec_0123456789876543210 _ a_0123456789876543210 a_0123456789876543210 = Apply (Apply FooListSym0 a_0123456789876543210) a_0123456789876543210+    type FoosPrec_0123456789876543210Sym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [a0123456789876543210]) (a0123456789876543210 :: [Bool]) =+        FoosPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (FoosPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) FoosPrec_0123456789876543210Sym2KindInference) ())+    data FoosPrec_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: [a0123456789876543210]) :: (~>) [Bool] [Bool]+      where+        FoosPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) FoosPrec_0123456789876543210Sym1KindInference) ())+    data FoosPrec_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: forall a0123456789876543210.+                                                                           (~>) [a0123456789876543210] ((~>) [Bool] [Bool])+      where+        FoosPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FoosPrec_0123456789876543210Sym0KindInference) ())+    data FoosPrec_0123456789876543210Sym0 :: forall a0123456789876543210.+                                             (~>) Nat ((~>) [a0123456789876543210] ((~>) [Bool] [Bool]))+      where+        FoosPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply FoosPrec_0123456789876543210Sym0 arg) (FoosPrec_0123456789876543210Sym1 arg) =>+                                                         FoosPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FoosPrec_0123456789876543210Sym0 a0123456789876543210 = FoosPrec_0123456789876543210Sym1 a0123456789876543210+    instance PFoo [a] where+      type FoosPrec a a a = Apply (Apply (Apply FoosPrec_0123456789876543210Sym0 a) a) a+    class SFoo a where+      sFoosPrec ::+        forall (t :: Nat) (t :: a) (t :: [Bool]).+        Sing t+        -> Sing t+           -> Sing t+              -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])+      sFooList ::+        forall (t :: a) (t :: [Bool]).+        Sing t -> Sing t -> Sing (Apply (Apply FooListSym0 t) t :: [Bool])+      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])+      sFooList+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (sUndefined sA_0123456789876543210) sA_0123456789876543210+    instance SFoo a => SFoo [a] where+      sFoosPrec ::+        forall (t :: Nat) (t :: [a]) (t :: [Bool]).+        Sing t+        -> Sing t+           -> Sing t+              -> Sing (Apply (Apply (Apply FoosPrecSym0 t) t) t :: [Bool])+      sFoosPrec+        _+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @FooListSym0) sFooList))+                sA_0123456789876543210))+            sA_0123456789876543210+    instance SFoo a =>+             SingI (FoosPrecSym0 :: (~>) Nat ((~>) a ((~>) [Bool] [Bool]))) where+      sing = (singFun3 @FoosPrecSym0) sFoosPrec+    instance (SFoo a, SingI d) =>+             SingI (FoosPrecSym1 (d :: Nat) :: (~>) a ((~>) [Bool] [Bool])) where+      sing = (singFun2 @(FoosPrecSym1 (d :: Nat))) (sFoosPrec (sing @d))+    instance (SFoo a, SingI d, SingI d) =>+             SingI (FoosPrecSym2 (d :: Nat) (d :: a) :: (~>) [Bool] [Bool]) where+      sing+        = (singFun1 @(FoosPrecSym2 (d :: Nat) (d :: a)))+            ((sFoosPrec (sing @d)) (sing @d))+    instance SFoo a =>+             SingI (FooListSym0 :: (~>) a ((~>) [Bool] [Bool])) where+      sing = (singFun2 @FooListSym0) sFooList+    instance (SFoo a, SingI d) =>+             SingI (FooListSym1 (d :: a) :: (~>) [Bool] [Bool]) where+      sing = (singFun1 @(FooListSym1 (d :: a))) (sFooList (sing @d))
− tests/compile-and-dump/Singletons/T172.ghc86.template 
@@ -1,40 +0,0 @@-Singletons/T172.hs:(0,0)-(0,0): Splicing declarations-    singletonsOnly-      [d| ($>) :: Nat -> Nat -> Nat-          ($>) = (+) |]-  ======>-    type ($>@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =-        ($>) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (($>@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:$>@#@$$###)) ())-    data ($>@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat-      where-        (:$>@#@$$###) :: forall a0123456789876543210-                                a0123456789876543210-                                arg. SameKind (Apply (($>@#@$$) a0123456789876543210) arg) (($>@#@$$$) a0123456789876543210 arg) =>-                         ($>@#@$$) a0123456789876543210 a0123456789876543210-    type instance Apply (($>@#@$$) a0123456789876543210) a0123456789876543210 = ($>) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ($>@#@$) where-      suppressUnusedWarnings = snd (((,) (:$>@#@$###)) ())-    data ($>@#@$) :: (~>) Nat ((~>) Nat Nat)-      where-        (:$>@#@$###) :: forall a0123456789876543210-                               arg. SameKind (Apply ($>@#@$) arg) (($>@#@$$) arg) =>-                        ($>@#@$) a0123456789876543210-    type instance Apply ($>@#@$) a0123456789876543210 = ($>@#@$$) a0123456789876543210-    type family ($>) (a :: Nat) (a :: Nat) :: Nat where-      ($>) a_0123456789876543210 a_0123456789876543210 = Apply (Apply (+@#@$) a_0123456789876543210) a_0123456789876543210-    (%$>) ::-      forall (t :: Nat) (t :: Nat).-      Sing t -> Sing t -> Sing (Apply (Apply ($>@#@$) t) t :: Nat)-    (%$>)-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((applySing ((singFun2 @(+@#@$)) (%+))) sA_0123456789876543210))-          sA_0123456789876543210-    instance SingI (($>@#@$) :: (~>) Nat ((~>) Nat Nat)) where-      sing = (singFun2 @($>@#@$)) (%$>)-    instance SingI d =>-             SingI (($>@#@$$) (d :: Nat) :: (~>) Nat Nat) where-      sing = (singFun1 @(($>@#@$$) (d :: Nat))) ((%$>) (sing @d))
+ tests/compile-and-dump/Singletons/T172.ghc88.template view
@@ -0,0 +1,40 @@+Singletons/T172.hs:(0,0)-(0,0): Splicing declarations+    singletonsOnly+      [d| ($>) :: Nat -> Nat -> Nat+          ($>) = (+) |]+  ======>+    type ($>@#@$$$) (a0123456789876543210 :: Nat) (a0123456789876543210 :: Nat) =+        ($>) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (($>@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:$>@#@$$###)) ())+    data ($>@#@$$) (a0123456789876543210 :: Nat) :: (~>) Nat Nat+      where+        (:$>@#@$$###) :: forall a0123456789876543210+                                a0123456789876543210+                                arg. SameKind (Apply (($>@#@$$) a0123456789876543210) arg) (($>@#@$$$) a0123456789876543210 arg) =>+                         ($>@#@$$) a0123456789876543210 a0123456789876543210+    type instance Apply (($>@#@$$) a0123456789876543210) a0123456789876543210 = ($>) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ($>@#@$) where+      suppressUnusedWarnings = snd (((,) (:$>@#@$###)) ())+    data ($>@#@$) :: (~>) Nat ((~>) Nat Nat)+      where+        (:$>@#@$###) :: forall a0123456789876543210+                               arg. SameKind (Apply ($>@#@$) arg) (($>@#@$$) arg) =>+                        ($>@#@$) a0123456789876543210+    type instance Apply ($>@#@$) a0123456789876543210 = ($>@#@$$) a0123456789876543210+    type family ($>) (a :: Nat) (a :: Nat) :: Nat where+      ($>) a_0123456789876543210 a_0123456789876543210 = Apply (Apply (+@#@$) a_0123456789876543210) a_0123456789876543210+    (%$>) ::+      forall (t :: Nat) (t :: Nat).+      Sing t -> Sing t -> Sing (Apply (Apply ($>@#@$) t) t :: Nat)+    (%$>)+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing+           ((applySing ((singFun2 @(+@#@$)) (%+))) sA_0123456789876543210))+          sA_0123456789876543210+    instance SingI (($>@#@$) :: (~>) Nat ((~>) Nat Nat)) where+      sing = (singFun2 @($>@#@$)) (%$>)+    instance SingI d =>+             SingI (($>@#@$$) (d :: Nat) :: (~>) Nat Nat) where+      sing = (singFun1 @(($>@#@$$) (d :: Nat))) ((%$>) (sing @d))
− tests/compile-and-dump/Singletons/T175.ghc86.template 
@@ -1,45 +0,0 @@-Singletons/T175.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| quux2 :: Bar2 a => a-          quux2 = baz-          -          class Foo a where-            baz :: a-          class Foo a => Bar1 a where-            quux1 :: a-            quux1 = baz-          class Foo a => Bar2 a |]-  ======>-    class Foo a where-      baz :: a-    class Foo a => Bar1 a where-      quux1 :: a-      quux1 = baz-    class Foo a => Bar2 a-    quux2 :: Bar2 a => a-    quux2 = baz-    type Quux2Sym0 = Quux2-    type family Quux2 :: a where-      Quux2 = BazSym0-    type BazSym0 = Baz-    class PFoo (a :: GHC.Types.Type) where-      type Baz :: a-    type Quux1Sym0 = Quux1-    type family Quux1_0123456789876543210 :: a where-      Quux1_0123456789876543210 = BazSym0-    type Quux1_0123456789876543210Sym0 = Quux1_0123456789876543210-    class PFoo a => PBar1 (a :: GHC.Types.Type) where-      type Quux1 :: a-      type Quux1 = Quux1_0123456789876543210Sym0-    class PFoo a => PBar2 (a :: GHC.Types.Type)-    sQuux2 :: forall a. SBar2 a => Sing (Quux2Sym0 :: a)-    sQuux2 = sBaz-    class SFoo a where-      sBaz :: Sing (BazSym0 :: a)-    class SFoo a => SBar1 a where-      sQuux1 :: Sing (Quux1Sym0 :: a)-      default sQuux1 ::-                (Quux1Sym0 :: a) ~ Quux1_0123456789876543210Sym0 =>-                Sing (Quux1Sym0 :: a)-      sQuux1 = sBaz-    class SFoo a => SBar2 a
+ tests/compile-and-dump/Singletons/T175.ghc88.template view
@@ -0,0 +1,45 @@+Singletons/T175.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| quux2 :: Bar2 a => a+          quux2 = baz+          +          class Foo a where+            baz :: a+          class Foo a => Bar1 a where+            quux1 :: a+            quux1 = baz+          class Foo a => Bar2 a |]+  ======>+    class Foo a where+      baz :: a+    class Foo a => Bar1 a where+      quux1 :: a+      quux1 = baz+    class Foo a => Bar2 a+    quux2 :: Bar2 a => a+    quux2 = baz+    type Quux2Sym0 = Quux2+    type family Quux2 :: a where+      Quux2 = BazSym0+    type BazSym0 = Baz+    class PFoo (a :: GHC.Types.Type) where+      type Baz :: a+    type Quux1Sym0 = Quux1+    type family Quux1_0123456789876543210 :: a where+      Quux1_0123456789876543210 = BazSym0+    type Quux1_0123456789876543210Sym0 = Quux1_0123456789876543210+    class PBar1 (a :: GHC.Types.Type) where+      type Quux1 :: a+      type Quux1 = Quux1_0123456789876543210Sym0+    class PBar2 (a :: GHC.Types.Type)+    sQuux2 :: forall a. SBar2 a => Sing (Quux2Sym0 :: a)+    sQuux2 = sBaz+    class SFoo a where+      sBaz :: Sing (BazSym0 :: a)+    class SFoo a => SBar1 a where+      sQuux1 :: Sing (Quux1Sym0 :: a)+      default sQuux1 ::+                ((Quux1Sym0 :: a) ~ Quux1_0123456789876543210Sym0) =>+                Sing (Quux1Sym0 :: a)+      sQuux1 = sBaz+    class SFoo a => SBar2 a
− tests/compile-and-dump/Singletons/T176.ghc86.template 
@@ -1,166 +0,0 @@-Singletons/T176.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| quux1 :: Foo1 a => a -> a-          quux1 x = x `bar1` \ _ -> baz1-          quux2 :: Foo2 a => a -> a-          quux2 x = x `bar2` baz2-          -          class Foo1 a where-            bar1 :: a -> (a -> b) -> b-            baz1 :: a-          class Foo2 a where-            bar2 :: a -> b -> b-            baz2 :: a |]-  ======>-    class Foo1 a where-      bar1 :: a -> (a -> b) -> b-      baz1 :: a-    quux1 :: Foo1 a => a -> a-    quux1 x = (x `bar1` (\ _ -> baz1))-    class Foo2 a where-      bar2 :: a -> b -> b-      baz2 :: a-    quux2 :: Foo2 a => a -> a-    quux2 x = (x `bar2` baz2)-    type family Case_0123456789876543210 x arg_0123456789876543210 t where-      Case_0123456789876543210 x arg_0123456789876543210 _ = Baz1Sym0-    type family Lambda_0123456789876543210 x t where-      Lambda_0123456789876543210 x arg_0123456789876543210 = Case_0123456789876543210 x arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 x0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210-    type Quux2Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Quux2 a0123456789876543210-    instance SuppressUnusedWarnings Quux2Sym0 where-      suppressUnusedWarnings = snd (((,) Quux2Sym0KindInference) ())-    data Quux2Sym0 :: forall a0123456789876543210.-                      (~>) a0123456789876543210 a0123456789876543210-      where-        Quux2Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply Quux2Sym0 arg) (Quux2Sym1 arg) =>-                                  Quux2Sym0 a0123456789876543210-    type instance Apply Quux2Sym0 a0123456789876543210 = Quux2 a0123456789876543210-    type Quux1Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Quux1 a0123456789876543210-    instance SuppressUnusedWarnings Quux1Sym0 where-      suppressUnusedWarnings = snd (((,) Quux1Sym0KindInference) ())-    data Quux1Sym0 :: forall a0123456789876543210.-                      (~>) a0123456789876543210 a0123456789876543210-      where-        Quux1Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply Quux1Sym0 arg) (Quux1Sym1 arg) =>-                                  Quux1Sym0 a0123456789876543210-    type instance Apply Quux1Sym0 a0123456789876543210 = Quux1 a0123456789876543210-    type family Quux2 (a :: a) :: a where-      Quux2 x = Apply (Apply Bar2Sym0 x) Baz2Sym0-    type family Quux1 (a :: a) :: a where-      Quux1 x = Apply (Apply Bar1Sym0 x) (Apply Lambda_0123456789876543210Sym0 x)-    type Bar1Sym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) =-        Bar1 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (Bar1Sym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Bar1Sym1KindInference) ())-    data Bar1Sym1 (arg0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                      (~>) ((~>) a0123456789876543210 b0123456789876543210) b0123456789876543210-      where-        Bar1Sym1KindInference :: forall arg0123456789876543210-                                        arg0123456789876543210-                                        arg. SameKind (Apply (Bar1Sym1 arg0123456789876543210) arg) (Bar1Sym2 arg0123456789876543210 arg) =>-                                 Bar1Sym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (Bar1Sym1 arg0123456789876543210) arg0123456789876543210 = Bar1 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings Bar1Sym0 where-      suppressUnusedWarnings = snd (((,) Bar1Sym0KindInference) ())-    data Bar1Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) ((~>) a0123456789876543210 b0123456789876543210) b0123456789876543210)-      where-        Bar1Sym0KindInference :: forall arg0123456789876543210-                                        arg. SameKind (Apply Bar1Sym0 arg) (Bar1Sym1 arg) =>-                                 Bar1Sym0 arg0123456789876543210-    type instance Apply Bar1Sym0 arg0123456789876543210 = Bar1Sym1 arg0123456789876543210-    type Baz1Sym0 = Baz1-    class PFoo1 (a :: Type) where-      type Bar1 (arg :: a) (arg :: (~>) a b) :: b-      type Baz1 :: a-    type Bar2Sym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: b0123456789876543210) =-        Bar2 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (Bar2Sym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Bar2Sym1KindInference) ())-    data Bar2Sym1 (arg0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                      (~>) b0123456789876543210 b0123456789876543210-      where-        Bar2Sym1KindInference :: forall arg0123456789876543210-                                        arg0123456789876543210-                                        arg. SameKind (Apply (Bar2Sym1 arg0123456789876543210) arg) (Bar2Sym2 arg0123456789876543210 arg) =>-                                 Bar2Sym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (Bar2Sym1 arg0123456789876543210) arg0123456789876543210 = Bar2 arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings Bar2Sym0 where-      suppressUnusedWarnings = snd (((,) Bar2Sym0KindInference) ())-    data Bar2Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)-      where-        Bar2Sym0KindInference :: forall arg0123456789876543210-                                        arg. SameKind (Apply Bar2Sym0 arg) (Bar2Sym1 arg) =>-                                 Bar2Sym0 arg0123456789876543210-    type instance Apply Bar2Sym0 arg0123456789876543210 = Bar2Sym1 arg0123456789876543210-    type Baz2Sym0 = Baz2-    class PFoo2 (a :: Type) where-      type Bar2 (arg :: a) (arg :: b) :: b-      type Baz2 :: a-    sQuux2 ::-      forall a (t :: a).-      SFoo2 a => Sing t -> Sing (Apply Quux2Sym0 t :: a)-    sQuux1 ::-      forall a (t :: a).-      SFoo1 a => Sing t -> Sing (Apply Quux1Sym0 t :: a)-    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)-                       -> (case sArg_0123456789876543210 of { _ -> sBaz1 }) ::-                            Sing (Case_0123456789876543210 x arg_0123456789876543210 arg_0123456789876543210) }))-    instance SFoo2 a => SingI (Quux2Sym0 :: (~>) a a) where-      sing = (singFun1 @Quux2Sym0) sQuux2-    instance SFoo1 a => SingI (Quux1Sym0 :: (~>) a a) where-      sing = (singFun1 @Quux1Sym0) sQuux1-    class SFoo1 a where-      sBar1 ::-        forall b (t :: a) (t :: (~>) a b).-        Sing t -> Sing t -> Sing (Apply (Apply Bar1Sym0 t) t :: b)-      sBaz1 :: Sing (Baz1Sym0 :: a)-    class SFoo2 a where-      sBar2 ::-        forall b (t :: a) (t :: b).-        Sing t -> Sing t -> Sing (Apply (Apply Bar2Sym0 t) t :: b)-      sBaz2 :: Sing (Baz2Sym0 :: a)-    instance SFoo1 a =>-             SingI (Bar1Sym0 :: (~>) a ((~>) ((~>) a b) b)) where-      sing = (singFun2 @Bar1Sym0) sBar1-    instance (SFoo1 a, SingI d) =>-             SingI (Bar1Sym1 (d :: a) :: (~>) ((~>) a b) b) where-      sing = (singFun1 @(Bar1Sym1 (d :: a))) (sBar1 (sing @d))-    instance SFoo2 a => SingI (Bar2Sym0 :: (~>) a ((~>) b b)) where-      sing = (singFun2 @Bar2Sym0) sBar2-    instance (SFoo2 a, SingI d) =>-             SingI (Bar2Sym1 (d :: a) :: (~>) b b) where-      sing = (singFun1 @(Bar2Sym1 (d :: a))) (sBar2 (sing @d))
+ tests/compile-and-dump/Singletons/T176.ghc88.template view
@@ -0,0 +1,167 @@+Singletons/T176.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| quux1 :: Foo1 a => a -> a+          quux1 x = x `bar1` \ _ -> baz1+          quux2 :: Foo2 a => a -> a+          quux2 x = x `bar2` baz2+          +          class Foo1 a where+            bar1 :: a -> (a -> b) -> b+            baz1 :: a+          class Foo2 a where+            bar2 :: a -> b -> b+            baz2 :: a |]+  ======>+    class Foo1 a where+      bar1 :: a -> (a -> b) -> b+      baz1 :: a+    quux1 :: Foo1 a => a -> a+    quux1 x = (x `bar1` (\ _ -> baz1))+    class Foo2 a where+      bar2 :: a -> b -> b+      baz2 :: a+    quux2 :: Foo2 a => a -> a+    quux2 x = (x `bar2` baz2)+    type family Case_0123456789876543210 arg_0123456789876543210 x t where+      Case_0123456789876543210 arg_0123456789876543210 x _ = Baz1Sym0+    type family Lambda_0123456789876543210 x t where+      Lambda_0123456789876543210 x arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 x arg_0123456789876543210+    type Lambda_0123456789876543210Sym2 x0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) arg) (Lambda_0123456789876543210Sym2 x0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym1 x0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym1 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type Quux2Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Quux2 a0123456789876543210+    instance SuppressUnusedWarnings Quux2Sym0 where+      suppressUnusedWarnings = snd (((,) Quux2Sym0KindInference) ())+    data Quux2Sym0 :: forall a0123456789876543210.+                      (~>) a0123456789876543210 a0123456789876543210+      where+        Quux2Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply Quux2Sym0 arg) (Quux2Sym1 arg) =>+                                  Quux2Sym0 a0123456789876543210+    type instance Apply Quux2Sym0 a0123456789876543210 = Quux2 a0123456789876543210+    type Quux1Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Quux1 a0123456789876543210+    instance SuppressUnusedWarnings Quux1Sym0 where+      suppressUnusedWarnings = snd (((,) Quux1Sym0KindInference) ())+    data Quux1Sym0 :: forall a0123456789876543210.+                      (~>) a0123456789876543210 a0123456789876543210+      where+        Quux1Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply Quux1Sym0 arg) (Quux1Sym1 arg) =>+                                  Quux1Sym0 a0123456789876543210+    type instance Apply Quux1Sym0 a0123456789876543210 = Quux1 a0123456789876543210+    type family Quux2 (a :: a) :: a where+      Quux2 x = Apply (Apply Bar2Sym0 x) Baz2Sym0+    type family Quux1 (a :: a) :: a where+      Quux1 x = Apply (Apply Bar1Sym0 x) (Apply Lambda_0123456789876543210Sym0 x)+    type Bar1Sym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) =+        Bar1 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (Bar1Sym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Bar1Sym1KindInference) ())+    data Bar1Sym1 (arg0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                      (~>) ((~>) a0123456789876543210 b0123456789876543210) b0123456789876543210+      where+        Bar1Sym1KindInference :: forall arg0123456789876543210+                                        arg0123456789876543210+                                        arg. SameKind (Apply (Bar1Sym1 arg0123456789876543210) arg) (Bar1Sym2 arg0123456789876543210 arg) =>+                                 Bar1Sym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (Bar1Sym1 arg0123456789876543210) arg0123456789876543210 = Bar1 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings Bar1Sym0 where+      suppressUnusedWarnings = snd (((,) Bar1Sym0KindInference) ())+    data Bar1Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) ((~>) a0123456789876543210 b0123456789876543210) b0123456789876543210)+      where+        Bar1Sym0KindInference :: forall arg0123456789876543210+                                        arg. SameKind (Apply Bar1Sym0 arg) (Bar1Sym1 arg) =>+                                 Bar1Sym0 arg0123456789876543210+    type instance Apply Bar1Sym0 arg0123456789876543210 = Bar1Sym1 arg0123456789876543210+    type Baz1Sym0 = Baz1+    class PFoo1 (a :: Type) where+      type Bar1 (arg :: a) (arg :: (~>) a b) :: b+      type Baz1 :: a+    type Bar2Sym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: b0123456789876543210) =+        Bar2 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (Bar2Sym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Bar2Sym1KindInference) ())+    data Bar2Sym1 (arg0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                      (~>) b0123456789876543210 b0123456789876543210+      where+        Bar2Sym1KindInference :: forall arg0123456789876543210+                                        arg0123456789876543210+                                        arg. SameKind (Apply (Bar2Sym1 arg0123456789876543210) arg) (Bar2Sym2 arg0123456789876543210 arg) =>+                                 Bar2Sym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (Bar2Sym1 arg0123456789876543210) arg0123456789876543210 = Bar2 arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings Bar2Sym0 where+      suppressUnusedWarnings = snd (((,) Bar2Sym0KindInference) ())+    data Bar2Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)+      where+        Bar2Sym0KindInference :: forall arg0123456789876543210+                                        arg. SameKind (Apply Bar2Sym0 arg) (Bar2Sym1 arg) =>+                                 Bar2Sym0 arg0123456789876543210+    type instance Apply Bar2Sym0 arg0123456789876543210 = Bar2Sym1 arg0123456789876543210+    type Baz2Sym0 = Baz2+    class PFoo2 (a :: Type) where+      type Bar2 (arg :: a) (arg :: b) :: b+      type Baz2 :: a+    sQuux2 ::+      forall a (t :: a).+      SFoo2 a => Sing t -> Sing (Apply Quux2Sym0 t :: a)+    sQuux1 ::+      forall a (t :: a).+      SFoo1 a => Sing t -> Sing (Apply Quux1Sym0 t :: a)+    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 }) }))+    instance SFoo2 a => SingI (Quux2Sym0 :: (~>) a a) where+      sing = (singFun1 @Quux2Sym0) sQuux2+    instance SFoo1 a => SingI (Quux1Sym0 :: (~>) a a) where+      sing = (singFun1 @Quux1Sym0) sQuux1+    class SFoo1 a where+      sBar1 ::+        forall b (t :: a) (t :: (~>) a b).+        Sing t -> Sing t -> Sing (Apply (Apply Bar1Sym0 t) t :: b)+      sBaz1 :: Sing (Baz1Sym0 :: a)+    class SFoo2 a where+      sBar2 ::+        forall b (t :: a) (t :: b).+        Sing t -> Sing t -> Sing (Apply (Apply Bar2Sym0 t) t :: b)+      sBaz2 :: Sing (Baz2Sym0 :: a)+    instance SFoo1 a =>+             SingI (Bar1Sym0 :: (~>) a ((~>) ((~>) a b) b)) where+      sing = (singFun2 @Bar1Sym0) sBar1+    instance (SFoo1 a, SingI d) =>+             SingI (Bar1Sym1 (d :: a) :: (~>) ((~>) a b) b) where+      sing = (singFun1 @(Bar1Sym1 (d :: a))) (sBar1 (sing @d))+    instance SFoo2 a => SingI (Bar2Sym0 :: (~>) a ((~>) b b)) where+      sing = (singFun2 @Bar2Sym0) sBar2+    instance (SFoo2 a, SingI d) =>+             SingI (Bar2Sym1 (d :: a) :: (~>) b b) where+      sing = (singFun1 @(Bar2Sym1 (d :: a))) (sBar2 (sing @d))
− tests/compile-and-dump/Singletons/T178.ghc86.template 
@@ -1,210 +0,0 @@-Singletons/T178.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| empty :: U-          empty = []-          -          data Occ-            = Str | Opt | Many-            deriving (Eq, Ord, Show)-          type U = [(Symbol, Occ)] |]-  ======>-    data Occ-      = Str | Opt | Many-      deriving (Eq, Ord, Show)-    type U = [(Symbol, Occ)]-    empty :: U-    empty = []-    type USym0 = U-    type StrSym0 = Str-    type OptSym0 = Opt-    type ManySym0 = Many-    type EmptySym0 = Empty-    type family Empty :: [(Symbol, Occ)] where-      Empty = '[]-    type family Compare_0123456789876543210 (a :: Occ) (a :: Occ) :: Ordering where-      Compare_0123456789876543210 Str Str = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 Opt Opt = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 Many Many = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-      Compare_0123456789876543210 Str Opt = LTSym0-      Compare_0123456789876543210 Str Many = LTSym0-      Compare_0123456789876543210 Opt Str = GTSym0-      Compare_0123456789876543210 Opt Many = LTSym0-      Compare_0123456789876543210 Many Str = GTSym0-      Compare_0123456789876543210 Many Opt = GTSym0-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Occ) (a0123456789876543210 :: Occ) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Occ) :: (~>) Occ Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) Occ ((~>) Occ Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd Occ where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family ShowsPrec_0123456789876543210 (a :: Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Occ) (a0123456789876543210 :: Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Occ) :: (~>) Symbol Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Occ ((~>) Symbol Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) Nat ((~>) Occ ((~>) Symbol Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow Occ where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family Equals_0123456789876543210 (a :: Occ) (b :: Occ) :: Bool where-      Equals_0123456789876543210 Str Str = TrueSym0-      Equals_0123456789876543210 Opt Opt = TrueSym0-      Equals_0123456789876543210 Many Many = TrueSym0-      Equals_0123456789876543210 (_ :: Occ) (_ :: Occ) = FalseSym0-    instance PEq Occ where-      type (==) a b = Equals_0123456789876543210 a b-    sEmpty :: Sing (EmptySym0 :: [(Symbol, Occ)])-    sEmpty = Data.Singletons.Prelude.Instances.SNil-    data instance Sing :: Occ -> GHC.Types.Type-      where-        SStr :: Sing Str-        SOpt :: Sing Opt-        SMany :: Sing Many-    type SOcc = (Sing :: Occ -> GHC.Types.Type)-    instance SingKind Occ where-      type Demote Occ = Occ-      fromSing SStr = Str-      fromSing SOpt = Opt-      fromSing SMany = Many-      toSing Str = SomeSing SStr-      toSing Opt = SomeSing SOpt-      toSing Many = SomeSing SMany-    instance SOrd Occ where-      sCompare ::-        forall (t1 :: Occ) (t2 :: Occ).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun Occ ((~>) Occ Ordering)-                                                 -> GHC.Types.Type) t1) t2)-      sCompare SStr SStr-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            Data.Singletons.Prelude.Instances.SNil-      sCompare SOpt SOpt-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            Data.Singletons.Prelude.Instances.SNil-      sCompare SMany SMany-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            Data.Singletons.Prelude.Instances.SNil-      sCompare SStr SOpt = SLT-      sCompare SStr SMany = SLT-      sCompare SOpt SStr = SGT-      sCompare SOpt SMany = SLT-      sCompare SMany SStr = SGT-      sCompare SMany SOpt = SGT-    instance SShow Occ where-      sShowsPrec ::-        forall (t1 :: Nat) (t2 :: Occ) (t3 :: Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun Nat ((~>) Occ ((~>) Symbol Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        _-        SStr-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "Str")))-            sA_0123456789876543210-      sShowsPrec-        _-        SOpt-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "Opt")))-            sA_0123456789876543210-      sShowsPrec-        _-        SMany-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "Many")))-            sA_0123456789876543210-    instance SEq Occ where-      (%==) SStr SStr = STrue-      (%==) SStr SOpt = SFalse-      (%==) SStr SMany = SFalse-      (%==) SOpt SStr = SFalse-      (%==) SOpt SOpt = STrue-      (%==) SOpt SMany = SFalse-      (%==) SMany SStr = SFalse-      (%==) SMany SOpt = SFalse-      (%==) SMany SMany = STrue-    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)-      (%~) 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)-      (%~) SMany SMany = Proved Refl-    deriving instance Show (Sing (z :: Occ))-    instance SingI Str where-      sing = SStr-    instance SingI Opt where-      sing = SOpt-    instance SingI Many where-      sing = SMany
+ tests/compile-and-dump/Singletons/T178.ghc88.template view
@@ -0,0 +1,221 @@+Singletons/T178.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| empty :: U+          empty = []+          +          data Occ+            = Str | Opt | Many+            deriving (Eq, Ord, Show)+          type U = [(Symbol, Occ)] |]+  ======>+    data Occ+      = Str | Opt | Many+      deriving (Eq, Ord, Show)+    type U = [(Symbol, Occ)]+    empty :: U+    empty = []+    type USym0 = U+    type StrSym0 = Str+    type OptSym0 = Opt+    type ManySym0 = Many+    type EmptySym0 = Empty+    type family Empty :: [(Symbol, Occ)] where+      Empty = '[]+    type family Compare_0123456789876543210 (a :: Occ) (a :: Occ) :: Ordering where+      Compare_0123456789876543210 Str Str = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 Opt Opt = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 Many Many = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+      Compare_0123456789876543210 Str Opt = LTSym0+      Compare_0123456789876543210 Str Many = LTSym0+      Compare_0123456789876543210 Opt Str = GTSym0+      Compare_0123456789876543210 Opt Many = LTSym0+      Compare_0123456789876543210 Many Str = GTSym0+      Compare_0123456789876543210 Many Opt = GTSym0+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Occ) (a0123456789876543210 :: Occ) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Occ) :: (~>) Occ Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) Occ ((~>) Occ Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd Occ where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family ShowsPrec_0123456789876543210 (a :: Nat) (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_0123456789876543210Sym3 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Occ) (a0123456789876543210 :: Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: Nat) (a0123456789876543210 :: Occ) :: (~>) Symbol Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: Nat) :: (~>) Occ ((~>) Symbol Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) Nat ((~>) Occ ((~>) Symbol Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow Occ where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family Equals_0123456789876543210 (a :: Occ) (b :: Occ) :: Bool where+      Equals_0123456789876543210 Str Str = TrueSym0+      Equals_0123456789876543210 Opt Opt = TrueSym0+      Equals_0123456789876543210 Many Many = TrueSym0+      Equals_0123456789876543210 (_ :: Occ) (_ :: Occ) = FalseSym0+    instance PEq Occ where+      type (==) a b = Equals_0123456789876543210 a b+    sEmpty :: Sing (EmptySym0 :: [(Symbol, Occ)])+    sEmpty = Data.Singletons.Prelude.Instances.SNil+    data SOcc :: Occ -> GHC.Types.Type+      where+        SStr :: SOcc Str+        SOpt :: SOcc Opt+        SMany :: SOcc Many+    type instance Sing @Occ = SOcc+    instance SingKind Occ where+      type Demote Occ = Occ+      fromSing SStr = Str+      fromSing SOpt = Opt+      fromSing SMany = Many+      toSing Str = SomeSing SStr+      toSing Opt = SomeSing SOpt+      toSing Many = SomeSing SMany+    instance SOrd Occ where+      sCompare ::+        forall (t1 :: Occ) (t2 :: Occ).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun Occ ((~>) Occ Ordering)+                                                 -> GHC.Types.Type) t1) t2)+      sCompare SStr SStr+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            Data.Singletons.Prelude.Instances.SNil+      sCompare SOpt SOpt+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            Data.Singletons.Prelude.Instances.SNil+      sCompare SMany SMany+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            Data.Singletons.Prelude.Instances.SNil+      sCompare SStr SOpt = SLT+      sCompare SStr SMany = SLT+      sCompare SOpt SStr = SGT+      sCompare SOpt SMany = SLT+      sCompare SMany SStr = SGT+      sCompare SMany SOpt = SGT+    instance SShow Occ where+      sShowsPrec ::+        forall (t1 :: Nat) (t2 :: Occ) (t3 :: Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun Nat ((~>) Occ ((~>) Symbol Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        _+        SStr+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "Str")))+            sA_0123456789876543210+      sShowsPrec+        _+        SOpt+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "Opt")))+            sA_0123456789876543210+      sShowsPrec+        _+        SMany+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "Many")))+            sA_0123456789876543210+    instance SEq Occ where+      (%==) SStr SStr = STrue+      (%==) SStr SOpt = SFalse+      (%==) SStr SMany = SFalse+      (%==) SOpt SStr = SFalse+      (%==) SOpt SOpt = STrue+      (%==) SOpt SMany = SFalse+      (%==) SMany SStr = SFalse+      (%==) SMany SOpt = SFalse+      (%==) SMany SMany = STrue+    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)+      (%~) 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)+      (%~) SMany SMany = Proved Refl+    instance Data.Type.Equality.TestEquality (SOcc :: Occ+                                                      -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance Data.Type.Coercion.TestCoercion (SOcc :: Occ+                                                      -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance Show (SOcc (z :: Occ)) where+      showsPrec _ SStr = showString "SStr"+      showsPrec _ SOpt = showString "SOpt"+      showsPrec _ SMany = showString "SMany"+    instance SingI Str where+      sing = SStr+    instance SingI Opt where+      sing = SOpt+    instance SingI Many where+      sing = SMany
− tests/compile-and-dump/Singletons/T183.ghc86.template 
@@ -1,512 +0,0 @@-Singletons/T183.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| f1 (x :: Maybe Bool) = (x :: Maybe Bool)-          f2 (x :: Maybe a) = (x :: Maybe a)-          f3 (Just a :: Maybe Bool) = "hi"-          g x = case Just x of { (Just y :: Maybe Bool) -> (y :: Bool) }-          foo1 :: Maybe a -> a-          foo1 (Just x :: Maybe a) = (x :: a)-          foo2, foo3 :: forall a. Maybe a -> a-          foo2 (Just x :: Maybe a) = (x :: a)-          foo3 (Just x) = (x :: a)-          foo4 :: (a, b) -> (b, a)-          foo4 = \ (x :: a, y :: b) -> (y :: b, x :: a)-          foo5, foo6 :: Maybe (Maybe a) -> Maybe (Maybe a)-          foo5 (Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a))-            = Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a)-          foo6 (Just x :: Maybe (Maybe a))-            = case x :: Maybe a of {-                (Just (y :: a) :: Maybe a) -> Just (Just (y :: a) :: Maybe a) }-          foo7 :: a -> b -> a-          foo7 (x :: a) (_ :: b) = (x :: a)-          foo8 :: forall a. Maybe a -> Maybe a-          foo8 x@(Just (_ :: a) :: Maybe a) = x-          foo9 :: a -> a-          foo9 (x :: a)-            = let-                g :: a -> b -> a-                g y _ = y-              in g x () |]-  ======>-    f1 (x :: Maybe Bool) = x :: Maybe Bool-    f2 (x :: Maybe a) = x :: Maybe a-    f3 (Just a :: Maybe Bool) = "hi"-    g x = case Just x of { (Just y :: Maybe Bool) -> y :: Bool }-    foo1 :: Maybe a -> a-    foo1 (Just x :: Maybe a) = x :: a-    foo2 :: forall a. Maybe a -> a-    foo3 :: forall a. Maybe a -> a-    foo2 (Just x :: Maybe a) = x :: a-    foo3 (Just x) = x :: a-    foo4 :: (a, b) -> (b, a)-    foo4 = \ (x :: a, y :: b) -> (y :: b, x :: a)-    foo5 :: Maybe (Maybe a) -> Maybe (Maybe a)-    foo6 :: Maybe (Maybe a) -> Maybe (Maybe a)-    foo5 (Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a))-      = Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a)-    foo6 (Just x :: Maybe (Maybe a))-      = case x :: Maybe a of {-          (Just (y :: a) :: Maybe a) -> Just (Just (y :: a) :: Maybe a) }-    foo7 :: a -> b -> a-    foo7 (x :: a) (_ :: b) = x :: a-    foo8 :: forall a. Maybe a -> Maybe a-    foo8 x@(Just (_ :: a) :: Maybe a) = x-    foo9 :: a -> a-    foo9 (x :: a)-      = let-          g :: a -> b -> a-          g y _ = y-        in (g x) ()-    type Let0123456789876543210GSym3 x0123456789876543210 (a0123456789876543210 :: a) (a0123456789876543210 :: b0123456789876543210) =-        Let0123456789876543210G x0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210GSym2KindInference) ())-    data Let0123456789876543210GSym2 x0123456789876543210 (a0123456789876543210 :: a) :: forall b0123456789876543210.-                                                                                         (~>) b0123456789876543210 a-      where-        Let0123456789876543210GSym2KindInference :: forall x0123456789876543210-                                                           a0123456789876543210-                                                           a0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210) arg) (Let0123456789876543210GSym3 x0123456789876543210 a0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210) a0123456789876543210 = Let0123456789876543210G a0123456789876543210 x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 x0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210GSym1KindInference) ())-    data Let0123456789876543210GSym1 x0123456789876543210 :: forall b0123456789876543210-                                                                    a.-                                                             (~>) a ((~>) b0123456789876543210 a)-      where-        Let0123456789876543210GSym1KindInference :: forall x0123456789876543210-                                                           a0123456789876543210-                                                           arg. SameKind (Apply (Let0123456789876543210GSym1 x0123456789876543210) arg) (Let0123456789876543210GSym2 x0123456789876543210 arg) =>-                                                    Let0123456789876543210GSym1 x0123456789876543210 a0123456789876543210-    type instance Apply (Let0123456789876543210GSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210GSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210GSym0KindInference) ())-    data Let0123456789876543210GSym0 x0123456789876543210-      where-        Let0123456789876543210GSym0KindInference :: forall x0123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>-                                                    Let0123456789876543210GSym0 x0123456789876543210-    type instance Apply Let0123456789876543210GSym0 x0123456789876543210 = Let0123456789876543210GSym1 x0123456789876543210-    type family Let0123456789876543210G x (a :: a) (a :: b) :: a where-      Let0123456789876543210G x y _ = y-    type Let0123456789876543210XSym1 wild_01234567898765432100123456789876543210 =-        Let0123456789876543210X wild_01234567898765432100123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210XSym0KindInference) ())-    data Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210-      where-        Let0123456789876543210XSym0KindInference :: forall wild_01234567898765432100123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>-                                                    Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210-    type instance Apply Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210-    type family Let0123456789876543210X wild_0123456789876543210 where-      Let0123456789876543210X wild_0123456789876543210 = (Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a)-    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 =-        Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 x where-      Let0123456789876543210Scrutinee_0123456789876543210 x = (x :: Maybe a)-    type family Case_0123456789876543210 x t where-      Case_0123456789876543210 x ( 'Just (y :: a) :: Maybe a) = Apply JustSym0 (Apply JustSym0 (y :: a) :: Maybe a)-    type family Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 t where-      Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 '((x :: a),-                                                                               (y :: b)) = Apply (Apply Tuple2Sym0 (y :: b)) (x :: a)-    type family Lambda_0123456789876543210 a_0123456789876543210 t where-      Lambda_0123456789876543210 a_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall a_01234567898765432100123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall a_01234567898765432100123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210-    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 =-        Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall x0123456789876543210-                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 x where-      Let0123456789876543210Scrutinee_0123456789876543210 x = Apply JustSym0 x-    type family Case_0123456789876543210 x t where-      Case_0123456789876543210 x ( 'Just y :: Maybe Bool) = (y :: Bool)-    type Foo9Sym1 (a0123456789876543210 :: a0123456789876543210) =-        Foo9 a0123456789876543210-    instance SuppressUnusedWarnings Foo9Sym0 where-      suppressUnusedWarnings = snd (((,) Foo9Sym0KindInference) ())-    data Foo9Sym0 :: forall a0123456789876543210.-                     (~>) a0123456789876543210 a0123456789876543210-      where-        Foo9Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo9Sym0 arg) (Foo9Sym1 arg) =>-                                 Foo9Sym0 a0123456789876543210-    type instance Apply Foo9Sym0 a0123456789876543210 = Foo9 a0123456789876543210-    type Foo8Sym1 (a0123456789876543210 :: Maybe a0123456789876543210) =-        Foo8 a0123456789876543210-    instance SuppressUnusedWarnings Foo8Sym0 where-      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())-    data Foo8Sym0 :: forall a0123456789876543210.-                     (~>) (Maybe a0123456789876543210) (Maybe a0123456789876543210)-      where-        Foo8Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>-                                 Foo8Sym0 a0123456789876543210-    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210-    type Foo7Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Foo7 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Foo7Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Foo7Sym1KindInference) ())-    data Foo7Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                    (~>) b0123456789876543210 a0123456789876543210-      where-        Foo7Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Foo7Sym1 a0123456789876543210) arg) (Foo7Sym2 a0123456789876543210 arg) =>-                                 Foo7Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Foo7Sym1 a0123456789876543210) a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Foo7Sym0 where-      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())-    data Foo7Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)-      where-        Foo7Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>-                                 Foo7Sym0 a0123456789876543210-    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7Sym1 a0123456789876543210-    type Foo6Sym1 (a0123456789876543210 :: Maybe (Maybe a0123456789876543210)) =-        Foo6 a0123456789876543210-    instance SuppressUnusedWarnings Foo6Sym0 where-      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())-    data Foo6Sym0 :: forall a0123456789876543210.-                     (~>) (Maybe (Maybe a0123456789876543210)) (Maybe (Maybe a0123456789876543210))-      where-        Foo6Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>-                                 Foo6Sym0 a0123456789876543210-    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6 a0123456789876543210-    type Foo5Sym1 (a0123456789876543210 :: Maybe (Maybe a0123456789876543210)) =-        Foo5 a0123456789876543210-    instance SuppressUnusedWarnings Foo5Sym0 where-      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())-    data Foo5Sym0 :: forall a0123456789876543210.-                     (~>) (Maybe (Maybe a0123456789876543210)) (Maybe (Maybe a0123456789876543210))-      where-        Foo5Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>-                                 Foo5Sym0 a0123456789876543210-    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210-    type Foo4Sym1 (a0123456789876543210 :: (a0123456789876543210,-                                            b0123456789876543210)) =-        Foo4 a0123456789876543210-    instance SuppressUnusedWarnings Foo4Sym0 where-      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())-    data Foo4Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) (a0123456789876543210,-                           b0123456789876543210) (b0123456789876543210, a0123456789876543210)-      where-        Foo4Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>-                                 Foo4Sym0 a0123456789876543210-    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210-    type Foo3Sym1 (a0123456789876543210 :: Maybe a0123456789876543210) =-        Foo3 a0123456789876543210-    instance SuppressUnusedWarnings Foo3Sym0 where-      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())-    data Foo3Sym0 :: forall a0123456789876543210.-                     (~>) (Maybe a0123456789876543210) a0123456789876543210-      where-        Foo3Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>-                                 Foo3Sym0 a0123456789876543210-    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210-    type Foo2Sym1 (a0123456789876543210 :: Maybe a0123456789876543210) =-        Foo2 a0123456789876543210-    instance SuppressUnusedWarnings Foo2Sym0 where-      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())-    data Foo2Sym0 :: forall a0123456789876543210.-                     (~>) (Maybe a0123456789876543210) a0123456789876543210-      where-        Foo2Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>-                                 Foo2Sym0 a0123456789876543210-    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2 a0123456789876543210-    type Foo1Sym1 (a0123456789876543210 :: Maybe a0123456789876543210) =-        Foo1 a0123456789876543210-    instance SuppressUnusedWarnings Foo1Sym0 where-      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())-    data Foo1Sym0 :: forall a0123456789876543210.-                     (~>) (Maybe a0123456789876543210) a0123456789876543210-      where-        Foo1Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>-                                 Foo1Sym0 a0123456789876543210-    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210-    type GSym1 a0123456789876543210 = G a0123456789876543210-    instance SuppressUnusedWarnings GSym0 where-      suppressUnusedWarnings = snd (((,) GSym0KindInference) ())-    data GSym0 a0123456789876543210-      where-        GSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply GSym0 arg) (GSym1 arg) =>-                              GSym0 a0123456789876543210-    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210-    type F3Sym1 a0123456789876543210 = F3 a0123456789876543210-    instance SuppressUnusedWarnings F3Sym0 where-      suppressUnusedWarnings = snd (((,) F3Sym0KindInference) ())-    data F3Sym0 a0123456789876543210-      where-        F3Sym0KindInference :: forall a0123456789876543210-                                      arg. SameKind (Apply F3Sym0 arg) (F3Sym1 arg) =>-                               F3Sym0 a0123456789876543210-    type instance Apply F3Sym0 a0123456789876543210 = F3 a0123456789876543210-    type F2Sym1 a0123456789876543210 = F2 a0123456789876543210-    instance SuppressUnusedWarnings F2Sym0 where-      suppressUnusedWarnings = snd (((,) F2Sym0KindInference) ())-    data F2Sym0 a0123456789876543210-      where-        F2Sym0KindInference :: forall a0123456789876543210-                                      arg. SameKind (Apply F2Sym0 arg) (F2Sym1 arg) =>-                               F2Sym0 a0123456789876543210-    type instance Apply F2Sym0 a0123456789876543210 = F2 a0123456789876543210-    type F1Sym1 a0123456789876543210 = F1 a0123456789876543210-    instance SuppressUnusedWarnings F1Sym0 where-      suppressUnusedWarnings = snd (((,) F1Sym0KindInference) ())-    data F1Sym0 a0123456789876543210-      where-        F1Sym0KindInference :: forall a0123456789876543210-                                      arg. SameKind (Apply F1Sym0 arg) (F1Sym1 arg) =>-                               F1Sym0 a0123456789876543210-    type instance Apply F1Sym0 a0123456789876543210 = F1 a0123456789876543210-    type family Foo9 (a :: a) :: a where-      Foo9 (x :: a) = Apply (Apply (Let0123456789876543210GSym1 x) x) Tuple0Sym0-    type family Foo8 (a :: Maybe a) :: Maybe a where-      Foo8 ( 'Just (wild_0123456789876543210 :: a) :: Maybe a) = Let0123456789876543210XSym1 wild_0123456789876543210-    type family Foo7 (a :: a) (a :: b) :: a where-      Foo7 (x :: a) (wild_0123456789876543210 :: b) = (x :: a)-    type family Foo6 (a :: Maybe (Maybe a)) :: Maybe (Maybe a) where-      Foo6 ( 'Just x :: Maybe (Maybe a)) = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)-    type family Foo5 (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 family Foo4 (a :: (a, b)) :: (b, a) where-      Foo4 a_0123456789876543210 = Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210-    type family Foo3 (a :: Maybe a) :: a where-      Foo3 ( 'Just x) = (x :: a)-    type family Foo2 (a :: Maybe a) :: a where-      Foo2 ( 'Just x :: Maybe a) = (x :: a)-    type family Foo1 (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)-    type family F3 a where-      F3 ( 'Just a :: Maybe Bool) = "hi"-    type family F2 a where-      F2 (x :: Maybe a) = (x :: Maybe a)-    type family F1 a where-      F1 (x :: Maybe Bool) = (x :: Maybe Bool)-    sFoo9 :: forall a (t :: a). Sing t -> Sing (Apply Foo9Sym0 t :: a)-    sFoo8 ::-      forall a (t :: Maybe a).-      Sing t -> Sing (Apply Foo8Sym0 t :: Maybe a)-    sFoo7 ::-      forall a b (t :: a) (t :: b).-      Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: a)-    sFoo6 ::-      forall a (t :: Maybe (Maybe a)).-      Sing t -> Sing (Apply Foo6Sym0 t :: Maybe (Maybe a))-    sFoo5 ::-      forall a (t :: Maybe (Maybe a)).-      Sing t -> Sing (Apply Foo5Sym0 t :: Maybe (Maybe a))-    sFoo4 ::-      forall a b (t :: (a, b)).-      Sing t -> Sing (Apply Foo4Sym0 t :: (b, a))-    sFoo3 ::-      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo3Sym0 t :: a)-    sFoo2 ::-      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo2Sym0 t :: a)-    sFoo1 ::-      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo1Sym0 t :: a)-    sG :: forall arg. Sing arg -> Sing (Apply GSym0 arg)-    sF3 :: forall arg. Sing arg -> Sing (Apply F3Sym0 arg)-    sF2 :: forall arg. Sing arg -> Sing (Apply F2Sym0 arg)-    sF1 :: forall arg. Sing arg -> Sing (Apply F1Sym0 arg)-    sFoo9 (sX :: Sing x)-      = case sX :: Sing x of {-          (_ :: Sing (x :: a))-            -> let-                 sG ::-                   forall b (t :: a) (t :: b).-                   Sing t-                   -> Sing t-                      -> Sing (Apply (Apply (Let0123456789876543210GSym1 x) t) t :: a)-                 sG (sY :: Sing y) _ = sY-               in-                 (applySing-                    ((applySing ((singFun2 @(Let0123456789876543210GSym1 x)) sG)) sX))-                   STuple0 }-    sFoo8-      (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210))-      = case-            ((,) (sWild_0123456789876543210 :: Sing wild_0123456789876543210))-              (SJust-                 (sWild_0123456789876543210 :: Sing wild_0123456789876543210))-        of {-          (,) (_ :: Sing (wild_0123456789876543210 :: a))-              (_ :: Sing ( 'Just (wild_0123456789876543210 :: a) :: Maybe a))-            -> let-                 sX :: Sing (Let0123456789876543210XSym1 wild_0123456789876543210)-                 sX-                   = (applySing ((singFun1 @JustSym0) SJust))-                       (sWild_0123456789876543210 ::-                          Sing (wild_0123456789876543210 :: a)) ::-                       Sing (Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a)-               in sX }-    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) }-    sFoo6 (SJust (sX :: Sing x))-      = case SJust (sX :: Sing x) of {-          (_ :: Sing ( 'Just x :: Maybe (Maybe a)))-            -> let-                 sScrutinee_0123456789876543210 ::-                   Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)-                 sScrutinee_0123456789876543210 = sX :: Sing (x :: Maybe a)-               in  (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)) } }) ::-                     Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) :: Maybe (Maybe a)) }-    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)) }-    sFoo4 (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((singFun1-               @(Apply Lambda_0123456789876543210Sym0 a_0123456789876543210))-              (\ sArg_0123456789876543210-                 -> case sArg_0123456789876543210 of {-                      (_ :: Sing 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)) } }) ::-                             Sing (Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210) })))-          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) }-    sFoo1 (SJust (sX :: Sing x))-      = case SJust (sX :: Sing x) of {-          (_ :: Sing ( 'Just x :: Maybe a)) -> sX :: Sing (x :: a) }-    sG (sX :: Sing x)-      = let-          sScrutinee_0123456789876543210 ::-            Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)-          sScrutinee_0123456789876543210-            = (applySing ((singFun1 @JustSym0) SJust)) sX-        in  (case sScrutinee_0123456789876543210 of {-               SJust (sY :: Sing y)-                 -> case SJust (sY :: Sing y) of {-                      (_ :: Sing ( 'Just y :: Maybe Bool))-                        -> sY :: Sing (y :: Bool) } }) ::-              Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x))-    sF3 (SJust (sA :: Sing a))-      = case SJust (sA :: Sing a) of {-          (_ :: Sing ( 'Just a :: Maybe Bool)) -> sing :: Sing "hi" }-    sF2 (sX :: Sing x)-      = case sX :: Sing x of {-          (_ :: Sing (x :: Maybe a)) -> sX :: Sing (x :: Maybe a) }-    sF1 (sX :: Sing x)-      = case sX :: Sing x of {-          (_ :: Sing (x :: Maybe Bool)) -> sX :: Sing (x :: Maybe Bool) }-    instance SingI (Foo9Sym0 :: (~>) a a) where-      sing = (singFun1 @Foo9Sym0) sFoo9-    instance SingI (Foo8Sym0 :: (~>) (Maybe a) (Maybe a)) where-      sing = (singFun1 @Foo8Sym0) sFoo8-    instance SingI (Foo7Sym0 :: (~>) a ((~>) b a)) where-      sing = (singFun2 @Foo7Sym0) sFoo7-    instance SingI d => SingI (Foo7Sym1 (d :: a) :: (~>) b a) where-      sing = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 (sing @d))-    instance SingI (Foo6Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))) where-      sing = (singFun1 @Foo6Sym0) sFoo6-    instance SingI (Foo5Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))) where-      sing = (singFun1 @Foo5Sym0) sFoo5-    instance SingI (Foo4Sym0 :: (~>) (a, b) (b, a)) where-      sing = (singFun1 @Foo4Sym0) sFoo4-    instance SingI (Foo3Sym0 :: (~>) (Maybe a) a) where-      sing = (singFun1 @Foo3Sym0) sFoo3-    instance SingI (Foo2Sym0 :: (~>) (Maybe a) a) where-      sing = (singFun1 @Foo2Sym0) sFoo2-    instance SingI (Foo1Sym0 :: (~>) (Maybe a) a) where-      sing = (singFun1 @Foo1Sym0) sFoo1-    instance SingI GSym0 where-      sing = (singFun1 @GSym0) sG-    instance SingI F3Sym0 where-      sing = (singFun1 @F3Sym0) sF3-    instance SingI F2Sym0 where-      sing = (singFun1 @F2Sym0) sF2-    instance SingI F1Sym0 where-      sing = (singFun1 @F1Sym0) sF1
+ tests/compile-and-dump/Singletons/T183.ghc88.template view
@@ -0,0 +1,516 @@+Singletons/T183.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| f1 (x :: Maybe Bool) = (x :: Maybe Bool)+          f2 (x :: Maybe a) = (x :: Maybe a)+          f3 (Just a :: Maybe Bool) = "hi"+          g x = case Just x of { (Just y :: Maybe Bool) -> (y :: Bool) }+          foo1 :: Maybe a -> a+          foo1 (Just x :: Maybe a) = (x :: a)+          foo2, foo3 :: forall a. Maybe a -> a+          foo2 (Just x :: Maybe a) = (x :: a)+          foo3 (Just x) = (x :: a)+          foo4 :: (a, b) -> (b, a)+          foo4 = \ (x :: a, y :: b) -> (y :: b, x :: a)+          foo5, foo6 :: Maybe (Maybe a) -> Maybe (Maybe a)+          foo5 (Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a))+            = Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a)+          foo6 (Just x :: Maybe (Maybe a))+            = case x :: Maybe a of {+                (Just (y :: a) :: Maybe a) -> Just (Just (y :: a) :: Maybe a) }+          foo7 :: a -> b -> a+          foo7 (x :: a) (_ :: b) = (x :: a)+          foo8 :: forall a. Maybe a -> Maybe a+          foo8 x@(Just (_ :: a) :: Maybe a) = x+          foo9 :: a -> a+          foo9 (x :: a)+            = let+                g :: a -> b -> a+                g y _ = y+              in g x () |]+  ======>+    f1 (x :: Maybe Bool) = x :: Maybe Bool+    f2 (x :: Maybe a) = x :: Maybe a+    f3 (Just a :: Maybe Bool) = "hi"+    g x = case Just x of { (Just y :: Maybe Bool) -> y :: Bool }+    foo1 :: Maybe a -> a+    foo1 (Just x :: Maybe a) = x :: a+    foo2 :: forall a. Maybe a -> a+    foo3 :: forall a. Maybe a -> a+    foo2 (Just x :: Maybe a) = x :: a+    foo3 (Just x) = x :: a+    foo4 :: (a, b) -> (b, a)+    foo4 = \ (x :: a, y :: b) -> (y :: b, x :: a)+    foo5 :: Maybe (Maybe a) -> Maybe (Maybe a)+    foo6 :: Maybe (Maybe a) -> Maybe (Maybe a)+    foo5 (Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a))+      = Just (Just (x :: a) :: Maybe a) :: Maybe (Maybe a)+    foo6 (Just x :: Maybe (Maybe a))+      = case x :: Maybe a of {+          (Just (y :: a) :: Maybe a) -> Just (Just (y :: a) :: Maybe a) }+    foo7 :: a -> b -> a+    foo7 (x :: a) (_ :: b) = x :: a+    foo8 :: forall a. Maybe a -> Maybe a+    foo8 x@(Just (_ :: a) :: Maybe a) = x+    foo9 :: a -> a+    foo9 (x :: a)+      = let+          g :: a -> b -> a+          g y _ = y+        in (g x) ()+    type Let0123456789876543210GSym3 x0123456789876543210 (a0123456789876543210 :: a) (a0123456789876543210 :: b0123456789876543210) =+        Let0123456789876543210G x0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210GSym2KindInference) ())+    data Let0123456789876543210GSym2 x0123456789876543210 (a0123456789876543210 :: a) :: forall b0123456789876543210.+                                                                                         (~>) b0123456789876543210 a+      where+        Let0123456789876543210GSym2KindInference :: forall x0123456789876543210+                                                           a0123456789876543210+                                                           a0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210) arg) (Let0123456789876543210GSym3 x0123456789876543210 a0123456789876543210 arg) =>+                                                    Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210 a0123456789876543210+    type instance Apply (Let0123456789876543210GSym2 a0123456789876543210 x0123456789876543210) a0123456789876543210 = Let0123456789876543210G a0123456789876543210 x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210GSym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210GSym1KindInference) ())+    data Let0123456789876543210GSym1 x0123456789876543210 :: forall a+                                                                    b0123456789876543210.+                                                             (~>) a ((~>) b0123456789876543210 a)+      where+        Let0123456789876543210GSym1KindInference :: forall x0123456789876543210+                                                           a0123456789876543210+                                                           arg. SameKind (Apply (Let0123456789876543210GSym1 x0123456789876543210) arg) (Let0123456789876543210GSym2 x0123456789876543210 arg) =>+                                                    Let0123456789876543210GSym1 x0123456789876543210 a0123456789876543210+    type instance Apply (Let0123456789876543210GSym1 x0123456789876543210) a0123456789876543210 = Let0123456789876543210GSym2 x0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210GSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210GSym0KindInference) ())+    data Let0123456789876543210GSym0 x0123456789876543210+      where+        Let0123456789876543210GSym0KindInference :: forall x0123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210GSym0 arg) (Let0123456789876543210GSym1 arg) =>+                                                    Let0123456789876543210GSym0 x0123456789876543210+    type instance Apply Let0123456789876543210GSym0 x0123456789876543210 = Let0123456789876543210GSym1 x0123456789876543210+    type family Let0123456789876543210G x (a :: a) (a :: b) :: a where+      Let0123456789876543210G x y _ = y+    type Let0123456789876543210XSym1 wild_01234567898765432100123456789876543210 =+        Let0123456789876543210X wild_01234567898765432100123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210XSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210XSym0KindInference) ())+    data Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210+      where+        Let0123456789876543210XSym0KindInference :: forall wild_01234567898765432100123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210XSym0 arg) (Let0123456789876543210XSym1 arg) =>+                                                    Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210+    type instance Apply Let0123456789876543210XSym0 wild_01234567898765432100123456789876543210 = Let0123456789876543210X wild_01234567898765432100123456789876543210+    type family Let0123456789876543210X wild_0123456789876543210 where+      Let0123456789876543210X wild_0123456789876543210 = Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a+    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 =+        Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210+    type family Let0123456789876543210Scrutinee_0123456789876543210 x where+      Let0123456789876543210Scrutinee_0123456789876543210 x = x :: Maybe a+    type family Case_0123456789876543210 x t where+      Case_0123456789876543210 x ('Just (y :: a) :: Maybe a) = Apply JustSym0 (Apply JustSym0 (y :: a) :: Maybe a)+    type family Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 t where+      Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 '(x :: a,+                                                                               y :: b) = Apply (Apply Tuple2Sym0 (y :: b)) (x :: a)+    type family Lambda_0123456789876543210 a_0123456789876543210 t where+      Lambda_0123456789876543210 a_0123456789876543210 arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 a_0123456789876543210 arg_0123456789876543210+    type Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall a_01234567898765432100123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) arg) (Lambda_0123456789876543210Sym2 a_01234567898765432100123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a_01234567898765432100123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall a_01234567898765432100123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 a_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym1 a_01234567898765432100123456789876543210+    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 x0123456789876543210 =+        Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 x0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 x0123456789876543210+    type family Let0123456789876543210Scrutinee_0123456789876543210 x where+      Let0123456789876543210Scrutinee_0123456789876543210 x = Apply JustSym0 x+    type family Case_0123456789876543210 x t where+      Case_0123456789876543210 x ('Just y :: Maybe Bool) = y :: Bool+    type Foo9Sym1 (a0123456789876543210 :: a0123456789876543210) =+        Foo9 a0123456789876543210+    instance SuppressUnusedWarnings Foo9Sym0 where+      suppressUnusedWarnings = snd (((,) Foo9Sym0KindInference) ())+    data Foo9Sym0 :: forall a0123456789876543210.+                     (~>) a0123456789876543210 a0123456789876543210+      where+        Foo9Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo9Sym0 arg) (Foo9Sym1 arg) =>+                                 Foo9Sym0 a0123456789876543210+    type instance Apply Foo9Sym0 a0123456789876543210 = Foo9 a0123456789876543210+    type Foo8Sym1 (a0123456789876543210 :: Maybe a0123456789876543210) =+        Foo8 a0123456789876543210+    instance SuppressUnusedWarnings Foo8Sym0 where+      suppressUnusedWarnings = snd (((,) Foo8Sym0KindInference) ())+    data Foo8Sym0 :: forall a0123456789876543210.+                     (~>) (Maybe a0123456789876543210) (Maybe a0123456789876543210)+      where+        Foo8Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo8Sym0 arg) (Foo8Sym1 arg) =>+                                 Foo8Sym0 a0123456789876543210+    type instance Apply Foo8Sym0 a0123456789876543210 = Foo8 a0123456789876543210+    type Foo7Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Foo7 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Foo7Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Foo7Sym1KindInference) ())+    data Foo7Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                    (~>) b0123456789876543210 a0123456789876543210+      where+        Foo7Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Foo7Sym1 a0123456789876543210) arg) (Foo7Sym2 a0123456789876543210 arg) =>+                                 Foo7Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Foo7Sym1 a0123456789876543210) a0123456789876543210 = Foo7 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Foo7Sym0 where+      suppressUnusedWarnings = snd (((,) Foo7Sym0KindInference) ())+    data Foo7Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        Foo7Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo7Sym0 arg) (Foo7Sym1 arg) =>+                                 Foo7Sym0 a0123456789876543210+    type instance Apply Foo7Sym0 a0123456789876543210 = Foo7Sym1 a0123456789876543210+    type Foo6Sym1 (a0123456789876543210 :: Maybe (Maybe a0123456789876543210)) =+        Foo6 a0123456789876543210+    instance SuppressUnusedWarnings Foo6Sym0 where+      suppressUnusedWarnings = snd (((,) Foo6Sym0KindInference) ())+    data Foo6Sym0 :: forall a0123456789876543210.+                     (~>) (Maybe (Maybe a0123456789876543210)) (Maybe (Maybe a0123456789876543210))+      where+        Foo6Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo6Sym0 arg) (Foo6Sym1 arg) =>+                                 Foo6Sym0 a0123456789876543210+    type instance Apply Foo6Sym0 a0123456789876543210 = Foo6 a0123456789876543210+    type Foo5Sym1 (a0123456789876543210 :: Maybe (Maybe a0123456789876543210)) =+        Foo5 a0123456789876543210+    instance SuppressUnusedWarnings Foo5Sym0 where+      suppressUnusedWarnings = snd (((,) Foo5Sym0KindInference) ())+    data Foo5Sym0 :: forall a0123456789876543210.+                     (~>) (Maybe (Maybe a0123456789876543210)) (Maybe (Maybe a0123456789876543210))+      where+        Foo5Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo5Sym0 arg) (Foo5Sym1 arg) =>+                                 Foo5Sym0 a0123456789876543210+    type instance Apply Foo5Sym0 a0123456789876543210 = Foo5 a0123456789876543210+    type Foo4Sym1 (a0123456789876543210 :: (a0123456789876543210,+                                            b0123456789876543210)) =+        Foo4 a0123456789876543210+    instance SuppressUnusedWarnings Foo4Sym0 where+      suppressUnusedWarnings = snd (((,) Foo4Sym0KindInference) ())+    data Foo4Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) (a0123456789876543210,+                           b0123456789876543210) (b0123456789876543210, a0123456789876543210)+      where+        Foo4Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo4Sym0 arg) (Foo4Sym1 arg) =>+                                 Foo4Sym0 a0123456789876543210+    type instance Apply Foo4Sym0 a0123456789876543210 = Foo4 a0123456789876543210+    type Foo3Sym1 (a0123456789876543210 :: Maybe a0123456789876543210) =+        Foo3 a0123456789876543210+    instance SuppressUnusedWarnings Foo3Sym0 where+      suppressUnusedWarnings = snd (((,) Foo3Sym0KindInference) ())+    data Foo3Sym0 :: forall a0123456789876543210.+                     (~>) (Maybe a0123456789876543210) a0123456789876543210+      where+        Foo3Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo3Sym0 arg) (Foo3Sym1 arg) =>+                                 Foo3Sym0 a0123456789876543210+    type instance Apply Foo3Sym0 a0123456789876543210 = Foo3 a0123456789876543210+    type Foo2Sym1 (a0123456789876543210 :: Maybe a0123456789876543210) =+        Foo2 a0123456789876543210+    instance SuppressUnusedWarnings Foo2Sym0 where+      suppressUnusedWarnings = snd (((,) Foo2Sym0KindInference) ())+    data Foo2Sym0 :: forall a0123456789876543210.+                     (~>) (Maybe a0123456789876543210) a0123456789876543210+      where+        Foo2Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo2Sym0 arg) (Foo2Sym1 arg) =>+                                 Foo2Sym0 a0123456789876543210+    type instance Apply Foo2Sym0 a0123456789876543210 = Foo2 a0123456789876543210+    type Foo1Sym1 (a0123456789876543210 :: Maybe a0123456789876543210) =+        Foo1 a0123456789876543210+    instance SuppressUnusedWarnings Foo1Sym0 where+      suppressUnusedWarnings = snd (((,) Foo1Sym0KindInference) ())+    data Foo1Sym0 :: forall a0123456789876543210.+                     (~>) (Maybe a0123456789876543210) a0123456789876543210+      where+        Foo1Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Foo1Sym0 arg) (Foo1Sym1 arg) =>+                                 Foo1Sym0 a0123456789876543210+    type instance Apply Foo1Sym0 a0123456789876543210 = Foo1 a0123456789876543210+    type GSym1 a0123456789876543210 = G a0123456789876543210+    instance SuppressUnusedWarnings GSym0 where+      suppressUnusedWarnings = snd (((,) GSym0KindInference) ())+    data GSym0 a0123456789876543210+      where+        GSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply GSym0 arg) (GSym1 arg) =>+                              GSym0 a0123456789876543210+    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210+    type F3Sym1 a0123456789876543210 = F3 a0123456789876543210+    instance SuppressUnusedWarnings F3Sym0 where+      suppressUnusedWarnings = snd (((,) F3Sym0KindInference) ())+    data F3Sym0 a0123456789876543210+      where+        F3Sym0KindInference :: forall a0123456789876543210+                                      arg. SameKind (Apply F3Sym0 arg) (F3Sym1 arg) =>+                               F3Sym0 a0123456789876543210+    type instance Apply F3Sym0 a0123456789876543210 = F3 a0123456789876543210+    type F2Sym1 a0123456789876543210 = F2 a0123456789876543210+    instance SuppressUnusedWarnings F2Sym0 where+      suppressUnusedWarnings = snd (((,) F2Sym0KindInference) ())+    data F2Sym0 a0123456789876543210+      where+        F2Sym0KindInference :: forall a0123456789876543210+                                      arg. SameKind (Apply F2Sym0 arg) (F2Sym1 arg) =>+                               F2Sym0 a0123456789876543210+    type instance Apply F2Sym0 a0123456789876543210 = F2 a0123456789876543210+    type F1Sym1 a0123456789876543210 = F1 a0123456789876543210+    instance SuppressUnusedWarnings F1Sym0 where+      suppressUnusedWarnings = snd (((,) F1Sym0KindInference) ())+    data F1Sym0 a0123456789876543210+      where+        F1Sym0KindInference :: forall a0123456789876543210+                                      arg. SameKind (Apply F1Sym0 arg) (F1Sym1 arg) =>+                               F1Sym0 a0123456789876543210+    type instance Apply F1Sym0 a0123456789876543210 = F1 a0123456789876543210+    type family Foo9 (a :: a) :: a where+      Foo9 (x :: a) = Apply (Apply (Let0123456789876543210GSym1 x) x) Tuple0Sym0+    type family Foo8 (a :: Maybe a) :: Maybe a where+      Foo8 ('Just (wild_0123456789876543210 :: a) :: Maybe a) = Let0123456789876543210XSym1 wild_0123456789876543210+    type family Foo7 (a :: a) (a :: b) :: a where+      Foo7 (x :: a) (wild_0123456789876543210 :: b) = x :: a+    type family Foo6 (a :: Maybe (Maybe a)) :: Maybe (Maybe a) where+      Foo6 ('Just x :: Maybe (Maybe a)) = Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)+    type family Foo5 (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 family Foo4 (a :: (a, b)) :: (b, a) where+      Foo4 a_0123456789876543210 = Apply (Apply Lambda_0123456789876543210Sym0 a_0123456789876543210) a_0123456789876543210+    type family Foo3 (a :: Maybe a) :: a where+      Foo3 ('Just x) = x :: a+    type family Foo2 (a :: Maybe a) :: a where+      Foo2 ('Just x :: Maybe a) = x :: a+    type family Foo1 (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)+    type family F3 a where+      F3 ('Just a :: Maybe Bool) = "hi"+    type family F2 a where+      F2 (x :: Maybe a) = x :: Maybe a+    type family F1 a where+      F1 (x :: Maybe Bool) = x :: Maybe Bool+    sFoo9 :: forall a (t :: a). Sing t -> Sing (Apply Foo9Sym0 t :: a)+    sFoo8 ::+      forall a (t :: Maybe a).+      Sing t -> Sing (Apply Foo8Sym0 t :: Maybe a)+    sFoo7 ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Foo7Sym0 t) t :: a)+    sFoo6 ::+      forall a (t :: Maybe (Maybe a)).+      Sing t -> Sing (Apply Foo6Sym0 t :: Maybe (Maybe a))+    sFoo5 ::+      forall a (t :: Maybe (Maybe a)).+      Sing t -> Sing (Apply Foo5Sym0 t :: Maybe (Maybe a))+    sFoo4 ::+      forall a b (t :: (a, b)).+      Sing t -> Sing (Apply Foo4Sym0 t :: (b, a))+    sFoo3 ::+      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo3Sym0 t :: a)+    sFoo2 ::+      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo2Sym0 t :: a)+    sFoo1 ::+      forall a (t :: Maybe a). Sing t -> Sing (Apply Foo1Sym0 t :: a)+    sG :: forall arg. Sing arg -> Sing (Apply GSym0 arg)+    sF3 :: forall arg. Sing arg -> Sing (Apply F3Sym0 arg)+    sF2 :: forall arg. Sing arg -> Sing (Apply F2Sym0 arg)+    sF1 :: forall arg. Sing arg -> Sing (Apply F1Sym0 arg)+    sFoo9 (sX :: Sing x)+      = case sX :: Sing x of {+          (_ :: Sing (x :: a))+            -> let+                 sG ::+                   forall b (t :: a) (t :: b).+                   Sing t+                   -> Sing t+                      -> Sing (Apply (Apply (Let0123456789876543210GSym1 x) t) t :: a)+                 sG (sY :: Sing y) _ = sY+               in+                 (applySing+                    ((applySing ((singFun2 @(Let0123456789876543210GSym1 x)) sG)) sX))+                   STuple0 }+    sFoo8+      (SJust (sWild_0123456789876543210 :: Sing wild_0123456789876543210))+      = case+            ((,) (sWild_0123456789876543210 :: Sing wild_0123456789876543210))+              (SJust+                 (sWild_0123456789876543210 :: Sing wild_0123456789876543210))+        of {+          (,) (_ :: Sing (wild_0123456789876543210 :: a))+              (_ :: Sing ('Just (wild_0123456789876543210 :: a) :: Maybe a))+            -> let+                 sX :: Sing (Let0123456789876543210XSym1 wild_0123456789876543210)+                 sX+                   = (applySing ((singFun1 @JustSym0) SJust))+                       (sWild_0123456789876543210 ::+                          Sing (wild_0123456789876543210 :: a)) ::+                       Sing (Apply JustSym0 (wild_0123456789876543210 :: a) :: Maybe a)+               in sX }+    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) }+    sFoo6 (SJust (sX :: Sing x))+      = case SJust (sX :: Sing x) of {+          (_ :: Sing ('Just x :: Maybe (Maybe a)))+            -> let+                 sScrutinee_0123456789876543210 ::+                   Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x)+                 sScrutinee_0123456789876543210 = sX :: Sing (x :: Maybe a)+               in+                 (id+                    @(Sing (Case_0123456789876543210 x (Let0123456789876543210Scrutinee_0123456789876543210Sym1 x) :: Maybe (Maybe a))))+                   (case sScrutinee_0123456789876543210 of {+                      SJust (sY :: Sing y)+                        -> case ((,) (sY :: Sing y)) (SJust (sY :: Sing y)) of {+                             (,) (_ :: Sing (y :: a)) (_ :: Sing ('Just (y :: a) :: Maybe a))+                               -> (applySing ((singFun1 @JustSym0) SJust))+                                    ((applySing ((singFun1 @JustSym0) SJust))+                                       (sY :: Sing (y :: a)) ::+                                       Sing (Apply JustSym0 (y :: a) :: Maybe a)) } }) }+    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)) }+    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)) } }) })))+          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) }+    sFoo1 (SJust (sX :: Sing x))+      = case SJust (sX :: Sing x) of {+          (_ :: Sing ('Just x :: Maybe a)) -> sX :: Sing (x :: a) }+    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) } })+    sF3 (SJust (sA :: Sing a))+      = case SJust (sA :: Sing a) of {+          (_ :: Sing ('Just a :: Maybe Bool)) -> sing :: Sing "hi" }+    sF2 (sX :: Sing x)+      = case sX :: Sing x of {+          (_ :: Sing (x :: Maybe a)) -> sX :: Sing (x :: Maybe a) }+    sF1 (sX :: Sing x)+      = case sX :: Sing x of {+          (_ :: Sing (x :: Maybe Bool)) -> sX :: Sing (x :: Maybe Bool) }+    instance SingI (Foo9Sym0 :: (~>) a a) where+      sing = (singFun1 @Foo9Sym0) sFoo9+    instance SingI (Foo8Sym0 :: (~>) (Maybe a) (Maybe a)) where+      sing = (singFun1 @Foo8Sym0) sFoo8+    instance SingI (Foo7Sym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @Foo7Sym0) sFoo7+    instance SingI d => SingI (Foo7Sym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(Foo7Sym1 (d :: a))) (sFoo7 (sing @d))+    instance SingI (Foo6Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))) where+      sing = (singFun1 @Foo6Sym0) sFoo6+    instance SingI (Foo5Sym0 :: (~>) (Maybe (Maybe a)) (Maybe (Maybe a))) where+      sing = (singFun1 @Foo5Sym0) sFoo5+    instance SingI (Foo4Sym0 :: (~>) (a, b) (b, a)) where+      sing = (singFun1 @Foo4Sym0) sFoo4+    instance SingI (Foo3Sym0 :: (~>) (Maybe a) a) where+      sing = (singFun1 @Foo3Sym0) sFoo3+    instance SingI (Foo2Sym0 :: (~>) (Maybe a) a) where+      sing = (singFun1 @Foo2Sym0) sFoo2+    instance SingI (Foo1Sym0 :: (~>) (Maybe a) a) where+      sing = (singFun1 @Foo1Sym0) sFoo1+    instance SingI GSym0 where+      sing = (singFun1 @GSym0) sG+    instance SingI F3Sym0 where+      sing = (singFun1 @F3Sym0) sF3+    instance SingI F2Sym0 where+      sing = (singFun1 @F2Sym0) sF2+    instance SingI F1Sym0 where+      sing = (singFun1 @F1Sym0) sF1
− tests/compile-and-dump/Singletons/T184.ghc86.template 
@@ -1,499 +0,0 @@-Singletons/T184.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| boogie :: Maybe a -> Maybe Bool -> Maybe a-          boogie ma mb-            = do a <- ma-                 b <- mb-                 guard b-                 return a-          zip' :: [a] -> [b] -> [(a, b)]-          zip' xs ys = [(x, y) | x <- xs |  y <- ys]-          cartProd :: [a] -> [b] -> [(a, b)]-          cartProd xs ys = [(x, y) | x <- xs, y <- ys]-          trues :: [Bool] -> [Bool]-          trues xs = [x | x <- xs, x] |]-  ======>-    boogie :: Maybe a -> Maybe Bool -> Maybe a-    boogie ma mb-      = do a <- ma-           b <- mb-           guard b-           return a-    zip' :: [a] -> [b] -> [(a, b)]-    zip' xs ys = [(x, y) | x <- xs |  y <- ys]-    cartProd :: [a] -> [b] -> [(a, b)]-    cartProd xs ys = [(x, y) | x <- xs, y <- ys]-    trues :: [Bool] -> [Bool]-    trues xs = [x | x <- xs, x]-    type family Lambda_0123456789876543210 xs t where-      Lambda_0123456789876543210 xs x = Apply (Apply (>>@#@$) (Apply GuardSym0 x)) (Apply ReturnSym0 x)-    type Lambda_0123456789876543210Sym2 xs0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 xs0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym2 xs0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym1 xs0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 xs0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210-    type family Lambda_0123456789876543210 xs ys x t where-      Lambda_0123456789876543210 xs ys x y = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)-    type Lambda_0123456789876543210Sym4 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 x0123456789876543210 ys0123456789876543210 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              x0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 x0123456789876543210) arg) (Lambda_0123456789876543210Sym4 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 x0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 x0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 x0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              x0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 x0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) x0123456789876543210 = Lambda_0123456789876543210Sym3 ys0123456789876543210 xs0123456789876543210 x0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 xs0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210-    type family Lambda_0123456789876543210 xs ys t where-      Lambda_0123456789876543210 xs ys x = Apply (Apply (>>=@#@$) ys) (Apply (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys) x)-    type Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 xs0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210-    type family Lambda_0123456789876543210 xs ys t where-      Lambda_0123456789876543210 xs ys x = Apply ReturnSym0 x-    type Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 xs0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210-    type family Lambda_0123456789876543210 xs ys t where-      Lambda_0123456789876543210 xs ys y = Apply ReturnSym0 y-    type Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 xs0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210-    type family Case_0123456789876543210 xs ys arg_0123456789876543210 t where-      Case_0123456789876543210 xs ys arg_0123456789876543210 '(x,-                                                               y) = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)-    type family Lambda_0123456789876543210 xs ys t where-      Lambda_0123456789876543210 xs ys arg_0123456789876543210 = Case_0123456789876543210 xs ys arg_0123456789876543210 arg_0123456789876543210-    type Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210-                                                              ys0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 xs0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210-    type family Lambda_0123456789876543210 ma mb a t where-      Lambda_0123456789876543210 ma mb a b = Apply (Apply (>>@#@$) (Apply GuardSym0 b)) (Apply ReturnSym0 a)-    type Lambda_0123456789876543210Sym4 ma0123456789876543210 mb0123456789876543210 a0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 ma0123456789876543210 mb0123456789876543210 a0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 a0123456789876543210 mb0123456789876543210 ma0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())-    data Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 a0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym3KindInference :: forall ma0123456789876543210-                                                              mb0123456789876543210-                                                              a0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 a0123456789876543210) arg) (Lambda_0123456789876543210Sym4 ma0123456789876543210 mb0123456789876543210 a0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 a0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym3 a0123456789876543210 mb0123456789876543210 ma0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 a0123456789876543210 mb0123456789876543210 ma0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 mb0123456789876543210 ma0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210 a0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall ma0123456789876543210-                                                              mb0123456789876543210-                                                              a0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210) arg) (Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210 a0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 mb0123456789876543210 ma0123456789876543210) a0123456789876543210 = Lambda_0123456789876543210Sym3 mb0123456789876543210 ma0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 ma0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 ma0123456789876543210 mb0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall ma0123456789876543210-                                                              mb0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 ma0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall ma0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 ma0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 ma0123456789876543210 = Lambda_0123456789876543210Sym1 ma0123456789876543210-    type family Lambda_0123456789876543210 ma mb t where-      Lambda_0123456789876543210 ma mb a = Apply (Apply (>>=@#@$) mb) (Apply (Apply (Apply Lambda_0123456789876543210Sym0 ma) mb) a)-    type Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 ma0123456789876543210 mb0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 mb0123456789876543210 ma0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall ma0123456789876543210-                                                              mb0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210) arg) (Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 mb0123456789876543210 ma0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 mb0123456789876543210 ma0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 ma0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 ma0123456789876543210 mb0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall ma0123456789876543210-                                                              mb0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 ma0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall ma0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 ma0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 ma0123456789876543210 = Lambda_0123456789876543210Sym1 ma0123456789876543210-    type TruesSym1 (a0123456789876543210 :: [Bool]) =-        Trues a0123456789876543210-    instance SuppressUnusedWarnings TruesSym0 where-      suppressUnusedWarnings = snd (((,) TruesSym0KindInference) ())-    data TruesSym0 :: (~>) [Bool] [Bool]-      where-        TruesSym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply TruesSym0 arg) (TruesSym1 arg) =>-                                  TruesSym0 a0123456789876543210-    type instance Apply TruesSym0 a0123456789876543210 = Trues a0123456789876543210-    type CartProdSym2 (a0123456789876543210 :: [a0123456789876543210]) (a0123456789876543210 :: [b0123456789876543210]) =-        CartProd a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (CartProdSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) CartProdSym1KindInference) ())-    data CartProdSym1 (a0123456789876543210 :: [a0123456789876543210]) :: forall b0123456789876543210.-                                                                          (~>) [b0123456789876543210] [(a0123456789876543210,-                                                                                                        b0123456789876543210)]-      where-        CartProdSym1KindInference :: forall a0123456789876543210-                                            a0123456789876543210-                                            arg. SameKind (Apply (CartProdSym1 a0123456789876543210) arg) (CartProdSym2 a0123456789876543210 arg) =>-                                     CartProdSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (CartProdSym1 a0123456789876543210) a0123456789876543210 = CartProd a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings CartProdSym0 where-      suppressUnusedWarnings = snd (((,) CartProdSym0KindInference) ())-    data CartProdSym0 :: forall a0123456789876543210-                                b0123456789876543210.-                         (~>) [a0123456789876543210] ((~>) [b0123456789876543210] [(a0123456789876543210,-                                                                                    b0123456789876543210)])-      where-        CartProdSym0KindInference :: forall a0123456789876543210-                                            arg. SameKind (Apply CartProdSym0 arg) (CartProdSym1 arg) =>-                                     CartProdSym0 a0123456789876543210-    type instance Apply CartProdSym0 a0123456789876543210 = CartProdSym1 a0123456789876543210-    type Zip'Sym2 (a0123456789876543210 :: [a0123456789876543210]) (a0123456789876543210 :: [b0123456789876543210]) =-        Zip' a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Zip'Sym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) Zip'Sym1KindInference) ())-    data Zip'Sym1 (a0123456789876543210 :: [a0123456789876543210]) :: forall b0123456789876543210.-                                                                      (~>) [b0123456789876543210] [(a0123456789876543210,-                                                                                                    b0123456789876543210)]-      where-        Zip'Sym1KindInference :: forall a0123456789876543210-                                        a0123456789876543210-                                        arg. SameKind (Apply (Zip'Sym1 a0123456789876543210) arg) (Zip'Sym2 a0123456789876543210 arg) =>-                                 Zip'Sym1 a0123456789876543210 a0123456789876543210-    type instance Apply (Zip'Sym1 a0123456789876543210) a0123456789876543210 = Zip' a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Zip'Sym0 where-      suppressUnusedWarnings = snd (((,) Zip'Sym0KindInference) ())-    data Zip'Sym0 :: forall a0123456789876543210 b0123456789876543210.-                     (~>) [a0123456789876543210] ((~>) [b0123456789876543210] [(a0123456789876543210,-                                                                                b0123456789876543210)])-      where-        Zip'Sym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply Zip'Sym0 arg) (Zip'Sym1 arg) =>-                                 Zip'Sym0 a0123456789876543210-    type instance Apply Zip'Sym0 a0123456789876543210 = Zip'Sym1 a0123456789876543210-    type BoogieSym2 (a0123456789876543210 :: Maybe a0123456789876543210) (a0123456789876543210 :: Maybe Bool) =-        Boogie a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (BoogieSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BoogieSym1KindInference) ())-    data BoogieSym1 (a0123456789876543210 :: Maybe a0123456789876543210) :: (~>) (Maybe Bool) (Maybe a0123456789876543210)-      where-        BoogieSym1KindInference :: forall a0123456789876543210-                                          a0123456789876543210-                                          arg. SameKind (Apply (BoogieSym1 a0123456789876543210) arg) (BoogieSym2 a0123456789876543210 arg) =>-                                   BoogieSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (BoogieSym1 a0123456789876543210) a0123456789876543210 = Boogie a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings BoogieSym0 where-      suppressUnusedWarnings = snd (((,) BoogieSym0KindInference) ())-    data BoogieSym0 :: forall a0123456789876543210.-                       (~>) (Maybe a0123456789876543210) ((~>) (Maybe Bool) (Maybe a0123456789876543210))-      where-        BoogieSym0KindInference :: forall a0123456789876543210-                                          arg. SameKind (Apply BoogieSym0 arg) (BoogieSym1 arg) =>-                                   BoogieSym0 a0123456789876543210-    type instance Apply BoogieSym0 a0123456789876543210 = BoogieSym1 a0123456789876543210-    type family Trues (a :: [Bool]) :: [Bool] where-      Trues xs = Apply (Apply (>>=@#@$) xs) (Apply Lambda_0123456789876543210Sym0 xs)-    type family CartProd (a :: [a]) (a :: [b]) :: [(a, b)] where-      CartProd xs ys = Apply (Apply (>>=@#@$) xs) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)-    type family Zip' (a :: [a]) (a :: [b]) :: [(a, b)] where-      Zip' xs ys = Apply (Apply (>>=@#@$) (Apply (Apply MzipSym0 (Apply (Apply (>>=@#@$) xs) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))) (Apply (Apply (>>=@#@$) ys) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)))) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)-    type family Boogie (a :: Maybe a) (a :: Maybe Bool) :: Maybe a where-      Boogie ma mb = Apply (Apply (>>=@#@$) ma) (Apply (Apply Lambda_0123456789876543210Sym0 ma) mb)-    sTrues ::-      forall (t :: [Bool]). Sing t -> Sing (Apply TruesSym0 t :: [Bool])-    sCartProd ::-      forall a b (t :: [a]) (t :: [b]).-      Sing t-      -> Sing t -> Sing (Apply (Apply CartProdSym0 t) t :: [(a, b)])-    sZip' ::-      forall a b (t :: [a]) (t :: [b]).-      Sing t -> Sing t -> Sing (Apply (Apply Zip'Sym0 t) t :: [(a, b)])-    sBoogie ::-      forall a (t :: Maybe a) (t :: Maybe Bool).-      Sing t -> Sing t -> Sing (Apply (Apply BoogieSym0 t) t :: Maybe a)-    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) }))-    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 xs) ys) x))-                               (\ sY-                                  -> case sY of {-                                       (_ :: Sing y)-                                         -> (applySing ((singFun1 @ReturnSym0) sReturn))-                                              ((applySing-                                                  ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX))-                                                 sY) })) }))-    sZip' (sXs :: Sing xs) (sYs :: Sing ys)-      = (applySing-           ((applySing ((singFun2 @(>>=@#@$)) (%>>=)))-              ((applySing-                  ((applySing ((singFun2 @MzipSym0) sMzip))-                     ((applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sXs))-                        ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))-                           (\ sX-                              -> case sX of {-                                   (_ :: Sing x)-                                     -> (applySing ((singFun1 @ReturnSym0) sReturn)) sX })))))-                 ((applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sYs))-                    ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))-                       (\ sY-                          -> case sY of {-                               (_ :: Sing y)-                                 -> (applySing ((singFun1 @ReturnSym0) sReturn)) sY }))))))-          ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))-             (\ sArg_0123456789876543210-                -> case sArg_0123456789876543210 of {-                     (_ :: Sing arg_0123456789876543210)-                       -> (case sArg_0123456789876543210 of {-                             STuple2 (sX :: Sing x) (sY :: Sing y)-                               -> (applySing ((singFun1 @ReturnSym0) sReturn))-                                    ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX))-                                       sY) }) ::-                            Sing (Case_0123456789876543210 xs ys arg_0123456789876543210 arg_0123456789876543210) }))-    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 ma) mb) a))-                               (\ sB-                                  -> case sB of {-                                       (_ :: 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-      sing = (singFun2 @CartProdSym0) sCartProd-    instance SingI d =>-             SingI (CartProdSym1 (d :: [a]) :: (~>) [b] [(a, b)]) where-      sing = (singFun1 @(CartProdSym1 (d :: [a]))) (sCartProd (sing @d))-    instance SingI (Zip'Sym0 :: (~>) [a] ((~>) [b] [(a, b)])) where-      sing = (singFun2 @Zip'Sym0) sZip'-    instance SingI d =>-             SingI (Zip'Sym1 (d :: [a]) :: (~>) [b] [(a, b)]) where-      sing = (singFun1 @(Zip'Sym1 (d :: [a]))) (sZip' (sing @d))-    instance SingI (BoogieSym0 :: (~>) (Maybe a) ((~>) (Maybe Bool) (Maybe a))) where-      sing = (singFun2 @BoogieSym0) sBoogie-    instance SingI d =>-             SingI (BoogieSym1 (d :: Maybe a) :: (~>) (Maybe Bool) (Maybe a)) where-      sing = (singFun1 @(BoogieSym1 (d :: Maybe a))) (sBoogie (sing @d))
+ tests/compile-and-dump/Singletons/T184.ghc88.template view
@@ -0,0 +1,500 @@+Singletons/T184.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| boogie :: Maybe a -> Maybe Bool -> Maybe a+          boogie ma mb+            = do a <- ma+                 b <- mb+                 guard b+                 return a+          zip' :: [a] -> [b] -> [(a, b)]+          zip' xs ys = [(x, y) | x <- xs |  y <- ys]+          cartProd :: [a] -> [b] -> [(a, b)]+          cartProd xs ys = [(x, y) | x <- xs, y <- ys]+          trues :: [Bool] -> [Bool]+          trues xs = [x | x <- xs, x] |]+  ======>+    boogie :: Maybe a -> Maybe Bool -> Maybe a+    boogie ma mb+      = do a <- ma+           b <- mb+           guard b+           return a+    zip' :: [a] -> [b] -> [(a, b)]+    zip' xs ys = [(x, y) | x <- xs |  y <- ys]+    cartProd :: [a] -> [b] -> [(a, b)]+    cartProd xs ys = [(x, y) | x <- xs, y <- ys]+    trues :: [Bool] -> [Bool]+    trues xs = [x | x <- xs, x]+    type family Lambda_0123456789876543210 xs t where+      Lambda_0123456789876543210 xs x = Apply (Apply (>>@#@$) (Apply GuardSym0 x)) (Apply ReturnSym0 x)+    type Lambda_0123456789876543210Sym2 xs0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 xs0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 xs0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym2 xs0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym1 xs0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym1 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 xs0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings Lambda_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 xs0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210+    type family Lambda_0123456789876543210 x xs ys t where+      Lambda_0123456789876543210 x xs ys y = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)+    type Lambda_0123456789876543210Sym4 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 ys0123456789876543210 xs0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall x0123456789876543210+                                                              xs0123456789876543210+                                                              ys0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym4 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym3 ys0123456789876543210 xs0123456789876543210 x0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 x0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 xs0123456789876543210 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210 ys0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall x0123456789876543210+                                                              xs0123456789876543210+                                                              ys0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210) arg) (Lambda_0123456789876543210Sym3 x0123456789876543210 xs0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 x0123456789876543210 xs0123456789876543210 ys0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 x0123456789876543210) ys0123456789876543210 = Lambda_0123456789876543210Sym3 xs0123456789876543210 x0123456789876543210 ys0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 x0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 x0123456789876543210 xs0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall x0123456789876543210+                                                              xs0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 x0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall x0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 x0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 x0123456789876543210 = Lambda_0123456789876543210Sym1 x0123456789876543210+    type family Lambda_0123456789876543210 xs ys t where+      Lambda_0123456789876543210 xs ys x = Apply (Apply (>>=@#@$) ys) (Apply (Apply (Apply Lambda_0123456789876543210Sym0 x) xs) ys)+    type Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210+                                                              ys0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210+                                                              ys0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 xs0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210+    type family Lambda_0123456789876543210 xs ys t where+      Lambda_0123456789876543210 xs ys x = Apply ReturnSym0 x+    type Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210+                                                              ys0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210+                                                              ys0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 xs0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210+    type family Lambda_0123456789876543210 xs ys t where+      Lambda_0123456789876543210 xs ys y = Apply ReturnSym0 y+    type Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210+                                                              ys0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210+                                                              ys0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 xs0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210+    type family Case_0123456789876543210 arg_0123456789876543210 xs ys t where+      Case_0123456789876543210 arg_0123456789876543210 xs ys '(x,+                                                               y) = Apply ReturnSym0 (Apply (Apply Tuple2Sym0 x) y)+    type family Lambda_0123456789876543210 xs ys t where+      Lambda_0123456789876543210 xs ys arg_0123456789876543210 = Case_0123456789876543210 arg_0123456789876543210 xs ys arg_0123456789876543210+    type Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall xs0123456789876543210+                                                              ys0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210) arg) (Lambda_0123456789876543210Sym3 xs0123456789876543210 ys0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 xs0123456789876543210 ys0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 ys0123456789876543210 xs0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 ys0123456789876543210 xs0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 xs0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 xs0123456789876543210 ys0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall xs0123456789876543210+                                                              ys0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 xs0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall xs0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 xs0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 xs0123456789876543210 = Lambda_0123456789876543210Sym1 xs0123456789876543210+    type family Lambda_0123456789876543210 a ma mb t where+      Lambda_0123456789876543210 a ma mb b = Apply (Apply (>>@#@$) (Apply GuardSym0 b)) (Apply ReturnSym0 a)+    type Lambda_0123456789876543210Sym4 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym3 mb0123456789876543210 ma0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym3KindInference) ())+    data Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym3KindInference :: forall a0123456789876543210+                                                              ma0123456789876543210+                                                              mb0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210) arg) (Lambda_0123456789876543210Sym4 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 mb0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym3 mb0123456789876543210 ma0123456789876543210 a0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 mb0123456789876543210 ma0123456789876543210 a0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 ma0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210 mb0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                              ma0123456789876543210+                                                              mb0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210) arg) (Lambda_0123456789876543210Sym3 a0123456789876543210 ma0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 a0123456789876543210 ma0123456789876543210 mb0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 ma0123456789876543210 a0123456789876543210) mb0123456789876543210 = Lambda_0123456789876543210Sym3 ma0123456789876543210 a0123456789876543210 mb0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 a0123456789876543210 ma0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                              ma0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 a0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 a0123456789876543210 = Lambda_0123456789876543210Sym1 a0123456789876543210+    type family Lambda_0123456789876543210 ma mb t where+      Lambda_0123456789876543210 ma mb a = Apply (Apply (>>=@#@$) mb) (Apply (Apply (Apply Lambda_0123456789876543210Sym0 a) ma) mb)+    type Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 ma0123456789876543210 mb0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 mb0123456789876543210 ma0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall ma0123456789876543210+                                                              mb0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210) arg) (Lambda_0123456789876543210Sym3 ma0123456789876543210 mb0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 ma0123456789876543210 mb0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 mb0123456789876543210 ma0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 mb0123456789876543210 ma0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 ma0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 ma0123456789876543210 mb0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall ma0123456789876543210+                                                              mb0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 ma0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall ma0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 ma0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 ma0123456789876543210 = Lambda_0123456789876543210Sym1 ma0123456789876543210+    type TruesSym1 (a0123456789876543210 :: [Bool]) =+        Trues a0123456789876543210+    instance SuppressUnusedWarnings TruesSym0 where+      suppressUnusedWarnings = snd (((,) TruesSym0KindInference) ())+    data TruesSym0 :: (~>) [Bool] [Bool]+      where+        TruesSym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply TruesSym0 arg) (TruesSym1 arg) =>+                                  TruesSym0 a0123456789876543210+    type instance Apply TruesSym0 a0123456789876543210 = Trues a0123456789876543210+    type CartProdSym2 (a0123456789876543210 :: [a0123456789876543210]) (a0123456789876543210 :: [b0123456789876543210]) =+        CartProd a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (CartProdSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) CartProdSym1KindInference) ())+    data CartProdSym1 (a0123456789876543210 :: [a0123456789876543210]) :: forall b0123456789876543210.+                                                                          (~>) [b0123456789876543210] [(a0123456789876543210,+                                                                                                        b0123456789876543210)]+      where+        CartProdSym1KindInference :: forall a0123456789876543210+                                            a0123456789876543210+                                            arg. SameKind (Apply (CartProdSym1 a0123456789876543210) arg) (CartProdSym2 a0123456789876543210 arg) =>+                                     CartProdSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (CartProdSym1 a0123456789876543210) a0123456789876543210 = CartProd a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings CartProdSym0 where+      suppressUnusedWarnings = snd (((,) CartProdSym0KindInference) ())+    data CartProdSym0 :: forall a0123456789876543210+                                b0123456789876543210.+                         (~>) [a0123456789876543210] ((~>) [b0123456789876543210] [(a0123456789876543210,+                                                                                    b0123456789876543210)])+      where+        CartProdSym0KindInference :: forall a0123456789876543210+                                            arg. SameKind (Apply CartProdSym0 arg) (CartProdSym1 arg) =>+                                     CartProdSym0 a0123456789876543210+    type instance Apply CartProdSym0 a0123456789876543210 = CartProdSym1 a0123456789876543210+    type Zip'Sym2 (a0123456789876543210 :: [a0123456789876543210]) (a0123456789876543210 :: [b0123456789876543210]) =+        Zip' a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Zip'Sym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) Zip'Sym1KindInference) ())+    data Zip'Sym1 (a0123456789876543210 :: [a0123456789876543210]) :: forall b0123456789876543210.+                                                                      (~>) [b0123456789876543210] [(a0123456789876543210,+                                                                                                    b0123456789876543210)]+      where+        Zip'Sym1KindInference :: forall a0123456789876543210+                                        a0123456789876543210+                                        arg. SameKind (Apply (Zip'Sym1 a0123456789876543210) arg) (Zip'Sym2 a0123456789876543210 arg) =>+                                 Zip'Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Zip'Sym1 a0123456789876543210) a0123456789876543210 = Zip' a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Zip'Sym0 where+      suppressUnusedWarnings = snd (((,) Zip'Sym0KindInference) ())+    data Zip'Sym0 :: forall a0123456789876543210 b0123456789876543210.+                     (~>) [a0123456789876543210] ((~>) [b0123456789876543210] [(a0123456789876543210,+                                                                                b0123456789876543210)])+      where+        Zip'Sym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply Zip'Sym0 arg) (Zip'Sym1 arg) =>+                                 Zip'Sym0 a0123456789876543210+    type instance Apply Zip'Sym0 a0123456789876543210 = Zip'Sym1 a0123456789876543210+    type BoogieSym2 (a0123456789876543210 :: Maybe a0123456789876543210) (a0123456789876543210 :: Maybe Bool) =+        Boogie a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (BoogieSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BoogieSym1KindInference) ())+    data BoogieSym1 (a0123456789876543210 :: Maybe a0123456789876543210) :: (~>) (Maybe Bool) (Maybe a0123456789876543210)+      where+        BoogieSym1KindInference :: forall a0123456789876543210+                                          a0123456789876543210+                                          arg. SameKind (Apply (BoogieSym1 a0123456789876543210) arg) (BoogieSym2 a0123456789876543210 arg) =>+                                   BoogieSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (BoogieSym1 a0123456789876543210) a0123456789876543210 = Boogie a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings BoogieSym0 where+      suppressUnusedWarnings = snd (((,) BoogieSym0KindInference) ())+    data BoogieSym0 :: forall a0123456789876543210.+                       (~>) (Maybe a0123456789876543210) ((~>) (Maybe Bool) (Maybe a0123456789876543210))+      where+        BoogieSym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply BoogieSym0 arg) (BoogieSym1 arg) =>+                                   BoogieSym0 a0123456789876543210+    type instance Apply BoogieSym0 a0123456789876543210 = BoogieSym1 a0123456789876543210+    type family Trues (a :: [Bool]) :: [Bool] where+      Trues xs = Apply (Apply (>>=@#@$) xs) (Apply Lambda_0123456789876543210Sym0 xs)+    type family CartProd (a :: [a]) (a :: [b]) :: [(a, b)] where+      CartProd xs ys = Apply (Apply (>>=@#@$) xs) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)+    type family Zip' (a :: [a]) (a :: [b]) :: [(a, b)] where+      Zip' xs ys = Apply (Apply (>>=@#@$) (Apply (Apply MzipSym0 (Apply (Apply (>>=@#@$) xs) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))) (Apply (Apply (>>=@#@$) ys) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)))) (Apply (Apply Lambda_0123456789876543210Sym0 xs) ys)+    type family Boogie (a :: Maybe a) (a :: Maybe Bool) :: Maybe a where+      Boogie ma mb = Apply (Apply (>>=@#@$) ma) (Apply (Apply Lambda_0123456789876543210Sym0 ma) mb)+    sTrues ::+      forall (t :: [Bool]). Sing t -> Sing (Apply TruesSym0 t :: [Bool])+    sCartProd ::+      forall a b (t :: [a]) (t :: [b]).+      Sing t+      -> Sing t -> Sing (Apply (Apply CartProdSym0 t) t :: [(a, b)])+    sZip' ::+      forall a b (t :: [a]) (t :: [b]).+      Sing t -> Sing t -> Sing (Apply (Apply Zip'Sym0 t) t :: [(a, b)])+    sBoogie ::+      forall a (t :: Maybe a) (t :: Maybe Bool).+      Sing t -> Sing t -> Sing (Apply (Apply BoogieSym0 t) t :: Maybe a)+    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) }))+    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) })) }))+    sZip' (sXs :: Sing xs) (sYs :: Sing ys)+      = (applySing+           ((applySing ((singFun2 @(>>=@#@$)) (%>>=)))+              ((applySing+                  ((applySing ((singFun2 @MzipSym0) sMzip))+                     ((applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sXs))+                        ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))+                           (\ sX+                              -> case sX of {+                                   (_ :: Sing x)+                                     -> (applySing ((singFun1 @ReturnSym0) sReturn)) sX })))))+                 ((applySing ((applySing ((singFun2 @(>>=@#@$)) (%>>=))) sYs))+                    ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))+                       (\ sY+                          -> case sY of {+                               (_ :: Sing y)+                                 -> (applySing ((singFun1 @ReturnSym0) sReturn)) sY }))))))+          ((singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 xs) ys))+             (\ sArg_0123456789876543210+                -> case sArg_0123456789876543210 of {+                     (_ :: Sing arg_0123456789876543210)+                       -> (id+                             @(Sing (Case_0123456789876543210 arg_0123456789876543210 xs ys arg_0123456789876543210)))+                            (case sArg_0123456789876543210 of {+                               STuple2 (sX :: Sing x) (sY :: Sing y)+                                 -> (applySing ((singFun1 @ReturnSym0) sReturn))+                                      ((applySing ((applySing ((singFun2 @Tuple2Sym0) STuple2)) sX))+                                         sY) }) }))+    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) })) }))+    instance SingI (TruesSym0 :: (~>) [Bool] [Bool]) where+      sing = (singFun1 @TruesSym0) sTrues+    instance SingI (CartProdSym0 :: (~>) [a] ((~>) [b] [(a, b)])) where+      sing = (singFun2 @CartProdSym0) sCartProd+    instance SingI d =>+             SingI (CartProdSym1 (d :: [a]) :: (~>) [b] [(a, b)]) where+      sing = (singFun1 @(CartProdSym1 (d :: [a]))) (sCartProd (sing @d))+    instance SingI (Zip'Sym0 :: (~>) [a] ((~>) [b] [(a, b)])) where+      sing = (singFun2 @Zip'Sym0) sZip'+    instance SingI d =>+             SingI (Zip'Sym1 (d :: [a]) :: (~>) [b] [(a, b)]) where+      sing = (singFun1 @(Zip'Sym1 (d :: [a]))) (sZip' (sing @d))+    instance SingI (BoogieSym0 :: (~>) (Maybe a) ((~>) (Maybe Bool) (Maybe a))) where+      sing = (singFun2 @BoogieSym0) sBoogie+    instance SingI d =>+             SingI (BoogieSym1 (d :: Maybe a) :: (~>) (Maybe Bool) (Maybe a)) where+      sing = (singFun1 @(BoogieSym1 (d :: Maybe a))) (sBoogie (sing @d))
− tests/compile-and-dump/Singletons/T187.ghc86.template 
@@ -1,57 +0,0 @@-Singletons/T187.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Empty-          -          deriving instance Ord Empty-          deriving instance Eq Empty |]-  ======>-    data Empty-    deriving instance Eq Empty-    deriving instance Ord Empty-    type family Compare_0123456789876543210 (a :: Empty) (a :: Empty) :: Ordering where-      Compare_0123456789876543210 _ _ = EQSym0-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Empty) (a0123456789876543210 :: Empty) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Empty) :: (~>) Empty Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) Empty ((~>) Empty Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd Empty where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Equals_0123456789876543210 (a :: Empty) (b :: Empty) :: Bool where-      Equals_0123456789876543210 (_ :: Empty) (_ :: Empty) = TrueSym0-    instance PEq Empty where-      type (==) a b = Equals_0123456789876543210 a b-    data instance Sing :: Empty -> GHC.Types.Type-    type SEmpty = (Sing :: Empty -> GHC.Types.Type)-    instance SingKind Empty where-      type Demote Empty = Empty-      fromSing x = case x of-      toSing x = SomeSing (case x of)-    instance SOrd Empty where-      sCompare ::-        forall (t1 :: Empty) (t2 :: Empty).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun Empty ((~>) Empty Ordering)-                                                 -> GHC.Types.Type) t1) t2)-      sCompare _ _ = SEQ-    instance SEq Empty where-      (%==) _ _ = STrue-    instance SDecide Empty where-      (%~) x _ = Proved (case x of)
+ tests/compile-and-dump/Singletons/T187.ghc88.template view
@@ -0,0 +1,65 @@+Singletons/T187.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Empty+          +          deriving instance Ord Empty+          deriving instance Eq Empty |]+  ======>+    data Empty+    deriving instance Eq Empty+    deriving instance Ord Empty+    type family Compare_0123456789876543210 (a :: Empty) (a :: Empty) :: Ordering where+      Compare_0123456789876543210 _ _ = EQSym0+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Empty) (a0123456789876543210 :: Empty) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Empty) :: (~>) Empty Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) Empty ((~>) Empty Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd Empty where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family Equals_0123456789876543210 (a :: Empty) (b :: Empty) :: Bool where+      Equals_0123456789876543210 (_ :: Empty) (_ :: Empty) = TrueSym0+    instance PEq Empty where+      type (==) a b = Equals_0123456789876543210 a b+    data SEmpty :: Empty -> GHC.Types.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)+    instance SOrd Empty where+      sCompare ::+        forall (t1 :: Empty) (t2 :: Empty).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun Empty ((~>) Empty Ordering)+                                                 -> GHC.Types.Type) t1) t2)+      sCompare _ _ = SEQ+    instance SEq Empty where+      (%==) _ _ = STrue+    instance SDecide Empty where+      (%~) x _ = Proved (case x of)+    instance Data.Type.Equality.TestEquality (SEmpty :: Empty+                                                        -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance Data.Type.Coercion.TestCoercion (SEmpty :: Empty+                                                        -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion
− tests/compile-and-dump/Singletons/T190.ghc86.template 
@@ -1,188 +0,0 @@-Singletons/T190.hs:0:0:: Splicing declarations-    singletons-      [d| data T-            = T-            deriving (Eq, Ord, Enum, Bounded, Show) |]-  ======>-    data T-      = T-      deriving (Eq, Ord, Enum, Bounded, Show)-    type TSym0 = T-    type family Compare_0123456789876543210 (a :: T) (a :: T) :: Ordering where-      Compare_0123456789876543210 T T = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: T) (a0123456789876543210 :: T) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: T) :: (~>) T Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: (~>) T ((~>) T Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd T where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Case_0123456789876543210 n t where-      Case_0123456789876543210 n  'True = TSym0-      Case_0123456789876543210 n  'False = Apply ErrorSym0 "toEnum: bad argument"-    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: T where-      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0))-    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =-        ToEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())-    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat T-      where-        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>-                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210-    type family FromEnum_0123456789876543210 (a :: T) :: GHC.Types.Nat where-      FromEnum_0123456789876543210 T = Data.Singletons.Prelude.Num.FromInteger 0-    type FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: T) =-        FromEnum_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())-    data FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Types.Nat-      where-        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>-                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210-    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210-    instance PEnum T where-      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a-      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a-    type family MinBound_0123456789876543210 :: T where-      MinBound_0123456789876543210 = TSym0-    type MinBound_0123456789876543210Sym0 =-        MinBound_0123456789876543210-    type family MaxBound_0123456789876543210 :: T where-      MaxBound_0123456789876543210 = TSym0-    type MaxBound_0123456789876543210Sym0 =-        MaxBound_0123456789876543210-    instance PBounded T where-      type MinBound = MinBound_0123456789876543210Sym0-      type MaxBound = MaxBound_0123456789876543210Sym0-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: T) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where-      ShowsPrec_0123456789876543210 _ T a_0123456789876543210 = Apply (Apply ShowStringSym0 "T") a_0123456789876543210-    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T) (a0123456789876543210 :: GHC.Types.Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T) :: (~>) GHC.Types.Symbol GHC.Types.Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow T where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family Equals_0123456789876543210 (a :: T) (b :: T) :: Bool where-      Equals_0123456789876543210 T T = TrueSym0-      Equals_0123456789876543210 (_ :: T) (_ :: T) = FalseSym0-    instance PEq T where-      type (==) a b = Equals_0123456789876543210 a b-    data instance Sing :: T -> GHC.Types.Type where ST :: Sing T-    type ST = (Sing :: T -> GHC.Types.Type)-    instance SingKind T where-      type Demote T = T-      fromSing ST = T-      toSing T = SomeSing ST-    instance SOrd T where-      sCompare ::-        forall (t1 :: T) (t2 :: T).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun T ((~>) T Ordering)-                                                 -> GHC.Types.Type) t1) t2)-      sCompare ST ST-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            Data.Singletons.Prelude.Instances.SNil-    instance SEnum T where-      sToEnum ::-        forall (t :: GHC.Types.Nat).-        Sing t-        -> Sing (Apply (Data.Singletons.Prelude.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat T-                                                                   -> GHC.Types.Type) t)-      sFromEnum ::-        forall (t :: T).-        Sing t-        -> Sing (Apply (Data.Singletons.Prelude.Enum.FromEnumSym0 :: TyFun T GHC.Types.Nat-                                                                     -> GHC.Types.Type) t)-      sToEnum (sN :: Sing n)-        = (case-               (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))-                 (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0))-           of-             STrue -> ST-             SFalse -> sError (sing :: Sing "toEnum: bad argument")) ::-            Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0)))-      sFromEnum ST-        = Data.Singletons.Prelude.Num.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.Types.Nat) (t2 :: T) (t3 :: GHC.Types.Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol))-                                                             -> GHC.Types.Type) t1) t2) t3)-      sShowsPrec-        _-        ST-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "T")))-            sA_0123456789876543210-    instance SEq T where-      (%==) ST ST = STrue-    instance SDecide T where-      (%~) ST ST = Proved Refl-    deriving instance Show (Sing (z :: T))-    instance SingI T where-      sing = ST
+ tests/compile-and-dump/Singletons/T190.ghc88.template view
@@ -0,0 +1,198 @@+Singletons/T190.hs:0:0:: Splicing declarations+    singletons+      [d| data T+            = T+            deriving (Eq, Ord, Enum, Bounded, Show) |]+  ======>+    data T+      = T+      deriving (Eq, Ord, Enum, Bounded, Show)+    type TSym0 = T+    type family Compare_0123456789876543210 (a :: T) (a :: T) :: Ordering where+      Compare_0123456789876543210 T T = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) '[]+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: T) (a0123456789876543210 :: T) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: T) :: (~>) T Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: (~>) T ((~>) T Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd T where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family Case_0123456789876543210 n t where+      Case_0123456789876543210 n 'True = TSym0+      Case_0123456789876543210 n 'False = Apply ErrorSym0 "toEnum: bad argument"+    type family ToEnum_0123456789876543210 (a :: GHC.Types.Nat) :: T where+      ToEnum_0123456789876543210 n = Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0))+    type ToEnum_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) =+        ToEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ToEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ToEnum_0123456789876543210Sym0KindInference) ())+    data ToEnum_0123456789876543210Sym0 :: (~>) GHC.Types.Nat T+      where+        ToEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                              arg. SameKind (Apply ToEnum_0123456789876543210Sym0 arg) (ToEnum_0123456789876543210Sym1 arg) =>+                                                       ToEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ToEnum_0123456789876543210Sym0 a0123456789876543210 = ToEnum_0123456789876543210 a0123456789876543210+    type family FromEnum_0123456789876543210 (a :: T) :: GHC.Types.Nat where+      FromEnum_0123456789876543210 T = Data.Singletons.Prelude.Num.FromInteger 0+    type FromEnum_0123456789876543210Sym1 (a0123456789876543210 :: T) =+        FromEnum_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings FromEnum_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) FromEnum_0123456789876543210Sym0KindInference) ())+    data FromEnum_0123456789876543210Sym0 :: (~>) T GHC.Types.Nat+      where+        FromEnum_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply FromEnum_0123456789876543210Sym0 arg) (FromEnum_0123456789876543210Sym1 arg) =>+                                                         FromEnum_0123456789876543210Sym0 a0123456789876543210+    type instance Apply FromEnum_0123456789876543210Sym0 a0123456789876543210 = FromEnum_0123456789876543210 a0123456789876543210+    instance PEnum T where+      type ToEnum a = Apply ToEnum_0123456789876543210Sym0 a+      type FromEnum a = Apply FromEnum_0123456789876543210Sym0 a+    type family MinBound_0123456789876543210 :: T where+      MinBound_0123456789876543210 = TSym0+    type MinBound_0123456789876543210Sym0 =+        MinBound_0123456789876543210+    type family MaxBound_0123456789876543210 :: T where+      MaxBound_0123456789876543210 = TSym0+    type MaxBound_0123456789876543210Sym0 =+        MaxBound_0123456789876543210+    instance PBounded T where+      type MinBound = MinBound_0123456789876543210Sym0+      type MaxBound = MaxBound_0123456789876543210Sym0+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (a :: T) (a :: GHC.Types.Symbol) :: GHC.Types.Symbol where+      ShowsPrec_0123456789876543210 _ T a_0123456789876543210 = Apply (Apply ShowStringSym0 "T") a_0123456789876543210+    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T) (a0123456789876543210 :: GHC.Types.Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: T) :: (~>) GHC.Types.Symbol GHC.Types.Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: (~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: (~>) GHC.Types.Nat ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow T where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family Equals_0123456789876543210 (a :: T) (b :: T) :: Bool where+      Equals_0123456789876543210 T T = TrueSym0+      Equals_0123456789876543210 (_ :: T) (_ :: T) = FalseSym0+    instance PEq T where+      type (==) a b = Equals_0123456789876543210 a b+    data ST :: T -> GHC.Types.Type where ST :: ST T+    type instance Sing @T = ST+    instance SingKind T where+      type Demote T = T+      fromSing ST = T+      toSing T = SomeSing ST+    instance SOrd T where+      sCompare ::+        forall (t1 :: T) (t2 :: T).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun T ((~>) T Ordering)+                                                 -> GHC.Types.Type) t1) t2)+      sCompare ST ST+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            Data.Singletons.Prelude.Instances.SNil+    instance SEnum T where+      sToEnum ::+        forall (t :: GHC.Types.Nat).+        Sing t+        -> Sing (Apply (Data.Singletons.Prelude.Enum.ToEnumSym0 :: TyFun GHC.Types.Nat T+                                                                   -> GHC.Types.Type) t)+      sFromEnum ::+        forall (t :: T).+        Sing t+        -> Sing (Apply (Data.Singletons.Prelude.Enum.FromEnumSym0 :: TyFun T GHC.Types.Nat+                                                                     -> GHC.Types.Type) t)+      sToEnum (sN :: Sing n)+        = (id+             @(Sing (Case_0123456789876543210 n (Apply (Apply (==@#@$) n) (Data.Singletons.Prelude.Num.FromInteger 0)))))+            (case+                 (applySing ((applySing ((singFun2 @(==@#@$)) (%==))) sN))+                   (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 0))+             of+               STrue -> ST+               SFalse -> sError (sing :: Sing "toEnum: bad argument"))+      sFromEnum ST+        = Data.Singletons.Prelude.Num.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.Types.Nat) (t2 :: T) (t3 :: GHC.Types.Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) T ((~>) GHC.Types.Symbol GHC.Types.Symbol))+                                                             -> GHC.Types.Type) t1) t2) t3)+      sShowsPrec+        _+        ST+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "T")))+            sA_0123456789876543210+    instance SEq T where+      (%==) ST ST = STrue+    instance SDecide T where+      (%~) ST ST = Proved Refl+    instance Data.Type.Equality.TestEquality (ST :: T+                                                    -> GHC.Types.Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance Data.Type.Coercion.TestCoercion (ST :: T+                                                    -> GHC.Types.Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance Show (ST (z :: T)) where+      showsPrec _ ST = showString "ST"+    instance SingI T where+      sing = ST
− tests/compile-and-dump/Singletons/T197.ghc86.template 
@@ -1,43 +0,0 @@-Singletons/T197.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| infixl 5 $$:-          -          ($$:) :: Bool -> Bool -> Bool-          _ $$: _ = False |]-  ======>-    infixl 5 $$:-    ($$:) :: Bool -> Bool -> Bool-    ($$:) _ _ = False-    type ($$:@#@$$$) (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) =-        ($$:) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (($$:@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:$$:@#@$$###)) ())-    data ($$:@#@$$) (a0123456789876543210 :: Bool) :: (~>) Bool Bool-      where-        (:$$:@#@$$###) :: forall a0123456789876543210-                                 a0123456789876543210-                                 arg. SameKind (Apply (($$:@#@$$) a0123456789876543210) arg) (($$:@#@$$$) a0123456789876543210 arg) =>-                          ($$:@#@$$) a0123456789876543210 a0123456789876543210-    type instance Apply (($$:@#@$$) a0123456789876543210) a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210-    infixl 5 $$:@#@$$-    instance SuppressUnusedWarnings ($$:@#@$) where-      suppressUnusedWarnings = snd (((,) (:$$:@#@$###)) ())-    data ($$:@#@$) :: (~>) Bool ((~>) Bool Bool)-      where-        (:$$:@#@$###) :: forall a0123456789876543210-                                arg. SameKind (Apply ($$:@#@$) arg) (($$:@#@$$) arg) =>-                         ($$:@#@$) a0123456789876543210-    type instance Apply ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210-    infixl 5 $$:@#@$-    type family ($$:) (a :: Bool) (a :: Bool) :: Bool where-      ($$:) _ _ = FalseSym0-    infixl 5 %$$:-    (%$$:) ::-      forall (t :: Bool) (t :: Bool).-      Sing t -> Sing t -> Sing (Apply (Apply ($$:@#@$) t) t :: Bool)-    (%$$:) _ _ = SFalse-    instance SingI (($$:@#@$) :: (~>) Bool ((~>) Bool Bool)) where-      sing = (singFun2 @($$:@#@$)) (%$$:)-    instance SingI d =>-             SingI (($$:@#@$$) (d :: Bool) :: (~>) Bool Bool) where-      sing = (singFun1 @(($$:@#@$$) (d :: Bool))) ((%$$:) (sing @d))
+ tests/compile-and-dump/Singletons/T197.ghc88.template view
@@ -0,0 +1,43 @@+Singletons/T197.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| infixl 5 $$:+          +          ($$:) :: Bool -> Bool -> Bool+          _ $$: _ = False |]+  ======>+    infixl 5 $$:+    ($$:) :: Bool -> Bool -> Bool+    ($$:) _ _ = False+    type ($$:@#@$$$) (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) =+        ($$:) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (($$:@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:$$:@#@$$###)) ())+    data ($$:@#@$$) (a0123456789876543210 :: Bool) :: (~>) Bool Bool+      where+        (:$$:@#@$$###) :: forall a0123456789876543210+                                 a0123456789876543210+                                 arg. SameKind (Apply (($$:@#@$$) a0123456789876543210) arg) (($$:@#@$$$) a0123456789876543210 arg) =>+                          ($$:@#@$$) a0123456789876543210 a0123456789876543210+    type instance Apply (($$:@#@$$) a0123456789876543210) a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210+    infixl 5 $$:@#@$$+    instance SuppressUnusedWarnings ($$:@#@$) where+      suppressUnusedWarnings = snd (((,) (:$$:@#@$###)) ())+    data ($$:@#@$) :: (~>) Bool ((~>) Bool Bool)+      where+        (:$$:@#@$###) :: forall a0123456789876543210+                                arg. SameKind (Apply ($$:@#@$) arg) (($$:@#@$$) arg) =>+                         ($$:@#@$) a0123456789876543210+    type instance Apply ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210+    infixl 5 $$:@#@$+    type family ($$:) (a :: Bool) (a :: Bool) :: Bool where+      ($$:) _ _ = FalseSym0+    infixl 5 %$$:+    (%$$:) ::+      forall (t :: Bool) (t :: Bool).+      Sing t -> Sing t -> Sing (Apply (Apply ($$:@#@$) t) t :: Bool)+    (%$$:) _ _ = SFalse+    instance SingI (($$:@#@$) :: (~>) Bool ((~>) Bool Bool)) where+      sing = (singFun2 @($$:@#@$)) (%$$:)+    instance SingI d =>+             SingI (($$:@#@$$) (d :: Bool) :: (~>) Bool Bool) where+      sing = (singFun1 @(($$:@#@$$) (d :: Bool))) ((%$$:) (sing @d))
− tests/compile-and-dump/Singletons/T197b.ghc86.template 
@@ -1,106 +0,0 @@-Singletons/T197b.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| infixr 9 `Pair`, `MkPair`-          -          data a :*: b = a :*: b-          data Pair a b = MkPair a b |]-  ======>-    data (:*:) a b = a :*: b-    data Pair a b = MkPair a b-    infixr 9 `Pair`-    infixr 9 `MkPair`-    type (:*:@#@$$$) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =-        (:*:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:*:@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())-    data (:*:@#@$$) (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                      (~>) b0123456789876543210 ((:*:) a0123456789876543210 b0123456789876543210)-      where-        (::*:@#@$$###) :: forall t0123456789876543210-                                 t0123456789876543210-                                 arg. SameKind (Apply ((:*:@#@$$) t0123456789876543210) arg) ((:*:@#@$$$) t0123456789876543210 arg) =>-                          (:*:@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:*:@#@$$) t0123456789876543210) t0123456789876543210 = (:*:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (:*:@#@$) where-      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())-    data (:*:@#@$) :: forall a0123456789876543210 b0123456789876543210.-                      (~>) a0123456789876543210 ((~>) b0123456789876543210 ((:*:) a0123456789876543210 b0123456789876543210))-      where-        (::*:@#@$###) :: forall t0123456789876543210-                                arg. SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>-                         (:*:@#@$) t0123456789876543210-    type instance Apply (:*:@#@$) t0123456789876543210 = (:*:@#@$$) t0123456789876543210-    type MkPairSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =-        MkPair t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkPairSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkPairSym1KindInference) ())-    data MkPairSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                      (~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210)-      where-        MkPairSym1KindInference :: forall t0123456789876543210-                                          t0123456789876543210-                                          arg. SameKind (Apply (MkPairSym1 t0123456789876543210) arg) (MkPairSym2 t0123456789876543210 arg) =>-                                   MkPairSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (MkPairSym1 t0123456789876543210) t0123456789876543210 = MkPair t0123456789876543210 t0123456789876543210-    infixr 9 `MkPairSym1`-    instance SuppressUnusedWarnings MkPairSym0 where-      suppressUnusedWarnings = snd (((,) MkPairSym0KindInference) ())-    data MkPairSym0 :: forall a0123456789876543210-                              b0123456789876543210.-                       (~>) a0123456789876543210 ((~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210))-      where-        MkPairSym0KindInference :: forall t0123456789876543210-                                          arg. SameKind (Apply MkPairSym0 arg) (MkPairSym1 arg) =>-                                   MkPairSym0 t0123456789876543210-    type instance Apply MkPairSym0 t0123456789876543210 = MkPairSym1 t0123456789876543210-    infixr 9 `MkPairSym0`-    infixr 9 `SPair`-    infixr 9 `SMkPair`-    data instance Sing :: (:*:) a b -> GHC.Types.Type-      where-        (:%*:) :: forall a b (n :: a) (n :: b).-                  (Sing (n :: a)) -> (Sing (n :: b)) -> Sing ((:*:) n n)-    type (%:*:) = (Sing :: (:*:) a b -> GHC.Types.Type)-    instance (SingKind a, SingKind b) => SingKind ((:*:) a b) where-      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) }-    data instance Sing :: Pair a b -> GHC.Types.Type-      where-        SMkPair :: forall a b (n :: a) (n :: b).-                   (Sing (n :: a)) -> (Sing (n :: b)) -> Sing (MkPair n n)-    type SPair = (Sing :: Pair a b -> GHC.Types.Type)-    instance (SingKind a, SingKind b) => SingKind (Pair a b) where-      type Demote (Pair a b) = Pair (Demote a) (Demote b)-      fromSing (SMkPair b b) = (MkPair (fromSing b)) (fromSing b)-      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) }-    instance (SingI n, SingI n) =>-             SingI ((:*:) (n :: a) (n :: b)) where-      sing = ((:%*:) sing) sing-    instance SingI ((:*:@#@$) :: (~>) a ((~>) b ((:*:) a b))) where-      sing = (singFun2 @(:*:@#@$)) (:%*:)-    instance SingI (TyCon2 (:*:) :: (~>) a ((~>) b ((:*:) a b))) where-      sing = (singFun2 @(TyCon2 (:*:))) (:%*:)-    instance SingI d =>-             SingI ((:*:@#@$$) (d :: a) :: (~>) b ((:*:) a b)) where-      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ((:*:) (d :: a)) :: (~>) b ((:*:) a b)) where-      sing = (singFun1 @(TyCon1 ((:*:) (d :: a)))) ((:%*:) (sing @d))-    instance (SingI n, SingI n) =>-             SingI (MkPair (n :: a) (n :: b)) where-      sing = (SMkPair sing) sing-    instance SingI (MkPairSym0 :: (~>) a ((~>) b (Pair a b))) where-      sing = (singFun2 @MkPairSym0) SMkPair-    instance SingI (TyCon2 MkPair :: (~>) a ((~>) b (Pair a b))) where-      sing = (singFun2 @(TyCon2 MkPair)) SMkPair-    instance SingI d =>-             SingI (MkPairSym1 (d :: a) :: (~>) b (Pair a b)) where-      sing = (singFun1 @(MkPairSym1 (d :: a))) (SMkPair (sing @d))-    instance SingI d =>-             SingI (TyCon1 (MkPair (d :: a)) :: (~>) b (Pair a b)) where-      sing = (singFun1 @(TyCon1 (MkPair (d :: a)))) (SMkPair (sing @d))
+ tests/compile-and-dump/Singletons/T197b.ghc88.template view
@@ -0,0 +1,96 @@+Singletons/T197b.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| infixr 9 `Pair`, `MkPair`+          +          data a :*: b = a :*: b+          data Pair a b = MkPair a b |]+  ======>+    data (:*:) a b = a :*: b+    data Pair a b = MkPair a b+    infixr 9 `Pair`+    infixr 9 `MkPair`+    type (:*:@#@$$$) (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =+        (:*:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:*:@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::*:@#@$$###)) ())+    data (:*:@#@$$) (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                      (~>) b0123456789876543210 ((:*:) a0123456789876543210 b0123456789876543210)+      where+        (::*:@#@$$###) :: forall t0123456789876543210+                                 t0123456789876543210+                                 arg. SameKind (Apply ((:*:@#@$$) t0123456789876543210) arg) ((:*:@#@$$$) t0123456789876543210 arg) =>+                          (:*:@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:*:@#@$$) t0123456789876543210) t0123456789876543210 = (:*:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (:*:@#@$) where+      suppressUnusedWarnings = snd (((,) (::*:@#@$###)) ())+    data (:*:@#@$) :: forall a0123456789876543210 b0123456789876543210.+                      (~>) a0123456789876543210 ((~>) b0123456789876543210 ((:*:) a0123456789876543210 b0123456789876543210))+      where+        (::*:@#@$###) :: forall t0123456789876543210+                                arg. SameKind (Apply (:*:@#@$) arg) ((:*:@#@$$) arg) =>+                         (:*:@#@$) t0123456789876543210+    type instance Apply (:*:@#@$) t0123456789876543210 = (:*:@#@$$) t0123456789876543210+    type MkPairSym2 (t0123456789876543210 :: a0123456789876543210) (t0123456789876543210 :: b0123456789876543210) =+        MkPair t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkPairSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkPairSym1KindInference) ())+    data MkPairSym1 (t0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                      (~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210)+      where+        MkPairSym1KindInference :: forall t0123456789876543210+                                          t0123456789876543210+                                          arg. SameKind (Apply (MkPairSym1 t0123456789876543210) arg) (MkPairSym2 t0123456789876543210 arg) =>+                                   MkPairSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (MkPairSym1 t0123456789876543210) t0123456789876543210 = MkPair t0123456789876543210 t0123456789876543210+    infixr 9 `MkPairSym1`+    instance SuppressUnusedWarnings MkPairSym0 where+      suppressUnusedWarnings = snd (((,) MkPairSym0KindInference) ())+    data MkPairSym0 :: forall a0123456789876543210+                              b0123456789876543210.+                       (~>) a0123456789876543210 ((~>) b0123456789876543210 (Pair a0123456789876543210 b0123456789876543210))+      where+        MkPairSym0KindInference :: forall t0123456789876543210+                                          arg. SameKind (Apply MkPairSym0 arg) (MkPairSym1 arg) =>+                                   MkPairSym0 t0123456789876543210+    type instance Apply MkPairSym0 t0123456789876543210 = MkPairSym1 t0123456789876543210+    infixr 9 `MkPairSym0`+    infixr 9 `SMkPair`+    infixr 9 `SPair`+    data (%:*:) :: forall a b. (:*:) a b -> GHC.Types.Type+      where+        (:%*:) :: forall a b (n :: a) (n :: b).+                  (Sing (n :: a)) -> (Sing (n :: b)) -> (%:*:) ((:*:) n n)+    type instance Sing @((:*:) a b) = (%:*:)+    instance (SingKind a, SingKind b) => SingKind ((:*:) a b) where+      type Demote ((:*:) a b) = (:*:) (Demote a) (Demote b)+      fromSing ((:%*:) b b) = ((:*:) (fromSing b)) (fromSing b)+      toSing ((:*:) (b :: Demote a) (b :: Demote b))+        = case ((,) (toSing b :: SomeSing a)) (toSing b :: SomeSing b) of {+            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%*:) c) c) }+    data SPair :: forall a b. Pair a b -> GHC.Types.Type+      where+        SMkPair :: forall a b (n :: a) (n :: b).+                   (Sing (n :: a)) -> (Sing (n :: b)) -> SPair (MkPair n n)+    type instance Sing @(Pair a b) = SPair+    instance (SingKind a, SingKind b) => SingKind (Pair a b) where+      type Demote (Pair a b) = Pair (Demote a) (Demote b)+      fromSing (SMkPair b b) = (MkPair (fromSing b)) (fromSing b)+      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) }+    instance (SingI n, SingI n) =>+             SingI ((:*:) (n :: a) (n :: b)) where+      sing = ((:%*:) sing) sing+    instance SingI ((:*:@#@$) :: (~>) a ((~>) b ((:*:) a b))) where+      sing = (singFun2 @(:*:@#@$)) (:%*:)+    instance SingI d =>+             SingI ((:*:@#@$$) (d :: a) :: (~>) b ((:*:) a b)) where+      sing = (singFun1 @((:*:@#@$$) (d :: a))) ((:%*:) (sing @d))+    instance (SingI n, SingI n) =>+             SingI (MkPair (n :: a) (n :: b)) where+      sing = (SMkPair sing) sing+    instance SingI (MkPairSym0 :: (~>) a ((~>) b (Pair a b))) where+      sing = (singFun2 @MkPairSym0) SMkPair+    instance SingI d =>+             SingI (MkPairSym1 (d :: a) :: (~>) b (Pair a b)) where+      sing = (singFun1 @(MkPairSym1 (d :: a))) (SMkPair (sing @d))
− tests/compile-and-dump/Singletons/T200.ghc86.template 
@@ -1,204 +0,0 @@-Singletons/T200.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| ($$:) :: ErrorMessage -> ErrorMessage -> ErrorMessage-          x $$: y = x :$$: y-          (<>:) :: ErrorMessage -> ErrorMessage -> ErrorMessage-          x <>: y = x :<>: y-          -          data ErrorMessage-            = ErrorMessage :$$: ErrorMessage |-              ErrorMessage :<>: ErrorMessage |-              EM [Bool] |]-  ======>-    data ErrorMessage-      = ErrorMessage :$$: ErrorMessage |-        ErrorMessage :<>: ErrorMessage |-        EM [Bool]-    ($$:) :: ErrorMessage -> ErrorMessage -> ErrorMessage-    ($$:) x y = (x :$$: y)-    (<>:) :: ErrorMessage -> ErrorMessage -> ErrorMessage-    (<>:) x y = (x :<>: y)-    type (:$$:@#@$$$) (t0123456789876543210 :: ErrorMessage) (t0123456789876543210 :: ErrorMessage) =-        (:$$:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:$$:@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::$$:@#@$$###)) ())-    data (:$$:@#@$$) (t0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage-      where-        (::$$:@#@$$###) :: forall t0123456789876543210-                                  t0123456789876543210-                                  arg. SameKind (Apply ((:$$:@#@$$) t0123456789876543210) arg) ((:$$:@#@$$$) t0123456789876543210 arg) =>-                           (:$$:@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:$$:@#@$$) t0123456789876543210) t0123456789876543210 = (:$$:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (:$$:@#@$) where-      suppressUnusedWarnings = snd (((,) (::$$:@#@$###)) ())-    data (:$$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)-      where-        (::$$:@#@$###) :: forall t0123456789876543210-                                 arg. SameKind (Apply (:$$:@#@$) arg) ((:$$:@#@$$) arg) =>-                          (:$$:@#@$) t0123456789876543210-    type instance Apply (:$$:@#@$) t0123456789876543210 = (:$$:@#@$$) t0123456789876543210-    type (:<>:@#@$$$) (t0123456789876543210 :: ErrorMessage) (t0123456789876543210 :: ErrorMessage) =-        (:<>:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings ((:<>:@#@$$) t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (::<>:@#@$$###)) ())-    data (:<>:@#@$$) (t0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage-      where-        (::<>:@#@$$###) :: forall t0123456789876543210-                                  t0123456789876543210-                                  arg. SameKind (Apply ((:<>:@#@$$) t0123456789876543210) arg) ((:<>:@#@$$$) t0123456789876543210 arg) =>-                           (:<>:@#@$$) t0123456789876543210 t0123456789876543210-    type instance Apply ((:<>:@#@$$) t0123456789876543210) t0123456789876543210 = (:<>:) t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (:<>:@#@$) where-      suppressUnusedWarnings = snd (((,) (::<>:@#@$###)) ())-    data (:<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)-      where-        (::<>:@#@$###) :: forall t0123456789876543210-                                 arg. SameKind (Apply (:<>:@#@$) arg) ((:<>:@#@$$) arg) =>-                          (:<>:@#@$) t0123456789876543210-    type instance Apply (:<>:@#@$) t0123456789876543210 = (:<>:@#@$$) t0123456789876543210-    type EMSym1 (t0123456789876543210 :: [Bool]) =-        EM t0123456789876543210-    instance SuppressUnusedWarnings EMSym0 where-      suppressUnusedWarnings = snd (((,) EMSym0KindInference) ())-    data EMSym0 :: (~>) [Bool] ErrorMessage-      where-        EMSym0KindInference :: forall t0123456789876543210-                                      arg. SameKind (Apply EMSym0 arg) (EMSym1 arg) =>-                               EMSym0 t0123456789876543210-    type instance Apply EMSym0 t0123456789876543210 = EM t0123456789876543210-    type (<>:@#@$$$) (a0123456789876543210 :: ErrorMessage) (a0123456789876543210 :: ErrorMessage) =-        (<>:) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((<>:@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:<>:@#@$$###)) ())-    data (<>:@#@$$) (a0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage-      where-        (:<>:@#@$$###) :: forall a0123456789876543210-                                 a0123456789876543210-                                 arg. SameKind (Apply ((<>:@#@$$) a0123456789876543210) arg) ((<>:@#@$$$) a0123456789876543210 arg) =>-                          (<>:@#@$$) a0123456789876543210 a0123456789876543210-    type instance Apply ((<>:@#@$$) a0123456789876543210) a0123456789876543210 = (<>:) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (<>:@#@$) where-      suppressUnusedWarnings = snd (((,) (:<>:@#@$###)) ())-    data (<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)-      where-        (:<>:@#@$###) :: forall a0123456789876543210-                                arg. SameKind (Apply (<>:@#@$) arg) ((<>:@#@$$) arg) =>-                         (<>:@#@$) a0123456789876543210-    type instance Apply (<>:@#@$) a0123456789876543210 = (<>:@#@$$) a0123456789876543210-    type ($$:@#@$$$) (a0123456789876543210 :: ErrorMessage) (a0123456789876543210 :: ErrorMessage) =-        ($$:) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (($$:@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:$$:@#@$$###)) ())-    data ($$:@#@$$) (a0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage-      where-        (:$$:@#@$$###) :: forall a0123456789876543210-                                 a0123456789876543210-                                 arg. SameKind (Apply (($$:@#@$$) a0123456789876543210) arg) (($$:@#@$$$) a0123456789876543210 arg) =>-                          ($$:@#@$$) a0123456789876543210 a0123456789876543210-    type instance Apply (($$:@#@$$) a0123456789876543210) a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ($$:@#@$) where-      suppressUnusedWarnings = snd (((,) (:$$:@#@$###)) ())-    data ($$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)-      where-        (:$$:@#@$###) :: forall a0123456789876543210-                                arg. SameKind (Apply ($$:@#@$) arg) (($$:@#@$$) arg) =>-                         ($$:@#@$) a0123456789876543210-    type instance Apply ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210-    type family (<>:) (a :: ErrorMessage) (a :: ErrorMessage) :: ErrorMessage where-      (<>:) x y = Apply (Apply (:<>:@#@$) x) y-    type family ($$:) (a :: ErrorMessage) (a :: ErrorMessage) :: ErrorMessage where-      ($$:) x y = Apply (Apply (:$$:@#@$) x) y-    (%<>:) ::-      forall (t :: ErrorMessage) (t :: ErrorMessage).-      Sing t-      -> Sing t -> Sing (Apply (Apply (<>:@#@$) t) t :: ErrorMessage)-    (%$$:) ::-      forall (t :: ErrorMessage) (t :: ErrorMessage).-      Sing t-      -> Sing t -> Sing (Apply (Apply ($$:@#@$) t) t :: ErrorMessage)-    (%<>:) (sX :: Sing x) (sY :: Sing y)-      = (applySing ((applySing ((singFun2 @(:<>:@#@$)) (:%<>:))) sX)) sY-    (%$$:) (sX :: Sing x) (sY :: Sing y)-      = (applySing ((applySing ((singFun2 @(:$$:@#@$)) (:%$$:))) sX)) sY-    instance SingI ((<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where-      sing = (singFun2 @(<>:@#@$)) (%<>:)-    instance SingI d =>-             SingI ((<>:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where-      sing-        = (singFun1 @((<>:@#@$$) (d :: ErrorMessage))) ((%<>:) (sing @d))-    instance SingI (($$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where-      sing = (singFun2 @($$:@#@$)) (%$$:)-    instance SingI d =>-             SingI (($$:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where-      sing-        = (singFun1 @(($$:@#@$$) (d :: ErrorMessage))) ((%$$:) (sing @d))-    data instance Sing :: ErrorMessage -> GHC.Types.Type-      where-        (:%$$:) :: forall (n :: ErrorMessage) (n :: ErrorMessage).-                   (Sing (n :: ErrorMessage))-                   -> (Sing (n :: ErrorMessage)) -> Sing ((:$$:) n n)-        (:%<>:) :: forall (n :: ErrorMessage) (n :: ErrorMessage).-                   (Sing (n :: ErrorMessage))-                   -> (Sing (n :: ErrorMessage)) -> Sing ((:<>:) n n)-        SEM :: forall (n :: [Bool]). (Sing (n :: [Bool])) -> Sing (EM n)-    type SErrorMessage = (Sing :: ErrorMessage -> GHC.Types.Type)-    instance SingKind ErrorMessage where-      type Demote ErrorMessage = ErrorMessage-      fromSing ((:%$$:) b b) = ((:$$:) (fromSing b)) (fromSing b)-      fromSing ((:%<>:) b b) = ((:<>:) (fromSing b)) (fromSing b)-      fromSing (SEM b) = EM (fromSing b)-      toSing-        ((:$$:) (b :: Demote ErrorMessage) (b :: Demote ErrorMessage))-        = case-              ((,) (toSing b :: SomeSing ErrorMessage))-                (toSing b :: SomeSing ErrorMessage)-          of {-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%$$:) c) c) }-      toSing-        ((:<>:) (b :: Demote ErrorMessage) (b :: Demote ErrorMessage))-        = case-              ((,) (toSing b :: SomeSing ErrorMessage))-                (toSing b :: SomeSing ErrorMessage)-          of {-            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%<>:) c) c) }-      toSing (EM (b :: Demote [Bool]))-        = case toSing b :: SomeSing [Bool] of {-            SomeSing c -> SomeSing (SEM c) }-    instance (SingI n, SingI n) =>-             SingI ((:$$:) (n :: ErrorMessage) (n :: ErrorMessage)) where-      sing = ((:%$$:) sing) sing-    instance SingI ((:$$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where-      sing = (singFun2 @(:$$:@#@$)) (:%$$:)-    instance SingI (TyCon2 (:$$:) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where-      sing = (singFun2 @(TyCon2 (:$$:))) (:%$$:)-    instance SingI d =>-             SingI ((:$$:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where-      sing-        = (singFun1 @((:$$:@#@$$) (d :: ErrorMessage))) ((:%$$:) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ((:$$:) (d :: ErrorMessage)) :: (~>) ErrorMessage ErrorMessage) where-      sing-        = (singFun1 @(TyCon1 ((:$$:) (d :: ErrorMessage))))-            ((:%$$:) (sing @d))-    instance (SingI n, SingI n) =>-             SingI ((:<>:) (n :: ErrorMessage) (n :: ErrorMessage)) where-      sing = ((:%<>:) sing) sing-    instance SingI ((:<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where-      sing = (singFun2 @(:<>:@#@$)) (:%<>:)-    instance SingI (TyCon2 (:<>:) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where-      sing = (singFun2 @(TyCon2 (:<>:))) (:%<>:)-    instance SingI d =>-             SingI ((:<>:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where-      sing-        = (singFun1 @((:<>:@#@$$) (d :: ErrorMessage))) ((:%<>:) (sing @d))-    instance SingI d =>-             SingI (TyCon1 ((:<>:) (d :: ErrorMessage)) :: (~>) ErrorMessage ErrorMessage) where-      sing-        = (singFun1 @(TyCon1 ((:<>:) (d :: ErrorMessage))))-            ((:%<>:) (sing @d))-    instance SingI n => SingI (EM (n :: [Bool])) where-      sing = SEM sing-    instance SingI (EMSym0 :: (~>) [Bool] ErrorMessage) where-      sing = (singFun1 @EMSym0) SEM-    instance SingI (TyCon1 EM :: (~>) [Bool] ErrorMessage) where-      sing = (singFun1 @(TyCon1 EM)) SEM
+ tests/compile-and-dump/Singletons/T200.ghc88.template view
@@ -0,0 +1,189 @@+Singletons/T200.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| ($$:) :: ErrorMessage -> ErrorMessage -> ErrorMessage+          x $$: y = x :$$: y+          (<>:) :: ErrorMessage -> ErrorMessage -> ErrorMessage+          x <>: y = x :<>: y+          +          data ErrorMessage+            = ErrorMessage :$$: ErrorMessage |+              ErrorMessage :<>: ErrorMessage |+              EM [Bool] |]+  ======>+    data ErrorMessage+      = ErrorMessage :$$: ErrorMessage |+        ErrorMessage :<>: ErrorMessage |+        EM [Bool]+    ($$:) :: ErrorMessage -> ErrorMessage -> ErrorMessage+    ($$:) x y = (x :$$: y)+    (<>:) :: ErrorMessage -> ErrorMessage -> ErrorMessage+    (<>:) x y = (x :<>: y)+    type (:$$:@#@$$$) (t0123456789876543210 :: ErrorMessage) (t0123456789876543210 :: ErrorMessage) =+        (:$$:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:$$:@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::$$:@#@$$###)) ())+    data (:$$:@#@$$) (t0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage+      where+        (::$$:@#@$$###) :: forall t0123456789876543210+                                  t0123456789876543210+                                  arg. SameKind (Apply ((:$$:@#@$$) t0123456789876543210) arg) ((:$$:@#@$$$) t0123456789876543210 arg) =>+                           (:$$:@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:$$:@#@$$) t0123456789876543210) t0123456789876543210 = (:$$:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (:$$:@#@$) where+      suppressUnusedWarnings = snd (((,) (::$$:@#@$###)) ())+    data (:$$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)+      where+        (::$$:@#@$###) :: forall t0123456789876543210+                                 arg. SameKind (Apply (:$$:@#@$) arg) ((:$$:@#@$$) arg) =>+                          (:$$:@#@$) t0123456789876543210+    type instance Apply (:$$:@#@$) t0123456789876543210 = (:$$:@#@$$) t0123456789876543210+    type (:<>:@#@$$$) (t0123456789876543210 :: ErrorMessage) (t0123456789876543210 :: ErrorMessage) =+        (:<>:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings ((:<>:@#@$$) t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (::<>:@#@$$###)) ())+    data (:<>:@#@$$) (t0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage+      where+        (::<>:@#@$$###) :: forall t0123456789876543210+                                  t0123456789876543210+                                  arg. SameKind (Apply ((:<>:@#@$$) t0123456789876543210) arg) ((:<>:@#@$$$) t0123456789876543210 arg) =>+                           (:<>:@#@$$) t0123456789876543210 t0123456789876543210+    type instance Apply ((:<>:@#@$$) t0123456789876543210) t0123456789876543210 = (:<>:) t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (:<>:@#@$) where+      suppressUnusedWarnings = snd (((,) (::<>:@#@$###)) ())+    data (:<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)+      where+        (::<>:@#@$###) :: forall t0123456789876543210+                                 arg. SameKind (Apply (:<>:@#@$) arg) ((:<>:@#@$$) arg) =>+                          (:<>:@#@$) t0123456789876543210+    type instance Apply (:<>:@#@$) t0123456789876543210 = (:<>:@#@$$) t0123456789876543210+    type EMSym1 (t0123456789876543210 :: [Bool]) =+        EM t0123456789876543210+    instance SuppressUnusedWarnings EMSym0 where+      suppressUnusedWarnings = snd (((,) EMSym0KindInference) ())+    data EMSym0 :: (~>) [Bool] ErrorMessage+      where+        EMSym0KindInference :: forall t0123456789876543210+                                      arg. SameKind (Apply EMSym0 arg) (EMSym1 arg) =>+                               EMSym0 t0123456789876543210+    type instance Apply EMSym0 t0123456789876543210 = EM t0123456789876543210+    type (<>:@#@$$$) (a0123456789876543210 :: ErrorMessage) (a0123456789876543210 :: ErrorMessage) =+        (<>:) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((<>:@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:<>:@#@$$###)) ())+    data (<>:@#@$$) (a0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage+      where+        (:<>:@#@$$###) :: forall a0123456789876543210+                                 a0123456789876543210+                                 arg. SameKind (Apply ((<>:@#@$$) a0123456789876543210) arg) ((<>:@#@$$$) a0123456789876543210 arg) =>+                          (<>:@#@$$) a0123456789876543210 a0123456789876543210+    type instance Apply ((<>:@#@$$) a0123456789876543210) a0123456789876543210 = (<>:) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (<>:@#@$) where+      suppressUnusedWarnings = snd (((,) (:<>:@#@$###)) ())+    data (<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)+      where+        (:<>:@#@$###) :: forall a0123456789876543210+                                arg. SameKind (Apply (<>:@#@$) arg) ((<>:@#@$$) arg) =>+                         (<>:@#@$) a0123456789876543210+    type instance Apply (<>:@#@$) a0123456789876543210 = (<>:@#@$$) a0123456789876543210+    type ($$:@#@$$$) (a0123456789876543210 :: ErrorMessage) (a0123456789876543210 :: ErrorMessage) =+        ($$:) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (($$:@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:$$:@#@$$###)) ())+    data ($$:@#@$$) (a0123456789876543210 :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage+      where+        (:$$:@#@$$###) :: forall a0123456789876543210+                                 a0123456789876543210+                                 arg. SameKind (Apply (($$:@#@$$) a0123456789876543210) arg) (($$:@#@$$$) a0123456789876543210 arg) =>+                          ($$:@#@$$) a0123456789876543210 a0123456789876543210+    type instance Apply (($$:@#@$$) a0123456789876543210) a0123456789876543210 = ($$:) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ($$:@#@$) where+      suppressUnusedWarnings = snd (((,) (:$$:@#@$###)) ())+    data ($$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)+      where+        (:$$:@#@$###) :: forall a0123456789876543210+                                arg. SameKind (Apply ($$:@#@$) arg) (($$:@#@$$) arg) =>+                         ($$:@#@$) a0123456789876543210+    type instance Apply ($$:@#@$) a0123456789876543210 = ($$:@#@$$) a0123456789876543210+    type family (<>:) (a :: ErrorMessage) (a :: ErrorMessage) :: ErrorMessage where+      (<>:) x y = Apply (Apply (:<>:@#@$) x) y+    type family ($$:) (a :: ErrorMessage) (a :: ErrorMessage) :: ErrorMessage where+      ($$:) x y = Apply (Apply (:$$:@#@$) x) y+    (%<>:) ::+      forall (t :: ErrorMessage) (t :: ErrorMessage).+      Sing t+      -> Sing t -> Sing (Apply (Apply (<>:@#@$) t) t :: ErrorMessage)+    (%$$:) ::+      forall (t :: ErrorMessage) (t :: ErrorMessage).+      Sing t+      -> Sing t -> Sing (Apply (Apply ($$:@#@$) t) t :: ErrorMessage)+    (%<>:) (sX :: Sing x) (sY :: Sing y)+      = (applySing ((applySing ((singFun2 @(:<>:@#@$)) (:%<>:))) sX)) sY+    (%$$:) (sX :: Sing x) (sY :: Sing y)+      = (applySing ((applySing ((singFun2 @(:$$:@#@$)) (:%$$:))) sX)) sY+    instance SingI ((<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where+      sing = (singFun2 @(<>:@#@$)) (%<>:)+    instance SingI d =>+             SingI ((<>:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where+      sing+        = (singFun1 @((<>:@#@$$) (d :: ErrorMessage))) ((%<>:) (sing @d))+    instance SingI (($$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where+      sing = (singFun2 @($$:@#@$)) (%$$:)+    instance SingI d =>+             SingI (($$:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where+      sing+        = (singFun1 @(($$:@#@$$) (d :: ErrorMessage))) ((%$$:) (sing @d))+    data SErrorMessage :: ErrorMessage -> GHC.Types.Type+      where+        (:%$$:) :: forall (n :: ErrorMessage) (n :: ErrorMessage).+                   (Sing (n :: ErrorMessage))+                   -> (Sing (n :: ErrorMessage)) -> SErrorMessage ((:$$:) n n)+        (:%<>:) :: forall (n :: ErrorMessage) (n :: ErrorMessage).+                   (Sing (n :: ErrorMessage))+                   -> (Sing (n :: ErrorMessage)) -> SErrorMessage ((:<>:) n n)+        SEM :: forall (n :: [Bool]).+               (Sing (n :: [Bool])) -> SErrorMessage (EM n)+    type instance Sing @ErrorMessage = SErrorMessage+    instance SingKind ErrorMessage where+      type Demote ErrorMessage = ErrorMessage+      fromSing ((:%$$:) b b) = ((:$$:) (fromSing b)) (fromSing b)+      fromSing ((:%<>:) b b) = ((:<>:) (fromSing b)) (fromSing b)+      fromSing (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) }+      toSing+        ((:<>:) (b :: Demote ErrorMessage) (b :: Demote ErrorMessage))+        = case+              ((,) (toSing b :: SomeSing ErrorMessage))+                (toSing b :: SomeSing ErrorMessage)+          of {+            (,) (SomeSing c) (SomeSing c) -> SomeSing (((:%<>:) c) c) }+      toSing (EM (b :: Demote [Bool]))+        = case toSing b :: SomeSing [Bool] of {+            SomeSing c -> SomeSing (SEM c) }+    instance (SingI n, SingI n) =>+             SingI ((:$$:) (n :: ErrorMessage) (n :: ErrorMessage)) where+      sing = ((:%$$:) sing) sing+    instance SingI ((:$$:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where+      sing = (singFun2 @(:$$:@#@$)) (:%$$:)+    instance SingI d =>+             SingI ((:$$:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where+      sing+        = (singFun1 @((:$$:@#@$$) (d :: ErrorMessage))) ((:%$$:) (sing @d))+    instance (SingI n, SingI n) =>+             SingI ((:<>:) (n :: ErrorMessage) (n :: ErrorMessage)) where+      sing = ((:%<>:) sing) sing+    instance SingI ((:<>:@#@$) :: (~>) ErrorMessage ((~>) ErrorMessage ErrorMessage)) where+      sing = (singFun2 @(:<>:@#@$)) (:%<>:)+    instance SingI d =>+             SingI ((:<>:@#@$$) (d :: ErrorMessage) :: (~>) ErrorMessage ErrorMessage) where+      sing+        = (singFun1 @((:<>:@#@$$) (d :: ErrorMessage))) ((:%<>:) (sing @d))+    instance SingI n => SingI (EM (n :: [Bool])) where+      sing = SEM sing+    instance SingI (EMSym0 :: (~>) [Bool] ErrorMessage) where+      sing = (singFun1 @EMSym0) SEM
− tests/compile-and-dump/Singletons/T206.ghc86.template 
+ tests/compile-and-dump/Singletons/T206.ghc88.template view
− tests/compile-and-dump/Singletons/T209.ghc86.template 
@@ -1,82 +0,0 @@-Singletons/T209.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| m :: a -> b -> Bool -> Bool-          m _ _ x = x-          -          class C a b-          data Hm-            = Hm-            deriving anyclass (C Bool)-          -          deriving anyclass instance C a a => C a (Maybe a) |]-  ======>-    class C a b-    m :: a -> b -> Bool -> Bool-    m _ _ x = x-    data Hm-      = Hm-      deriving anyclass (C Bool)-    deriving anyclass instance C a a => C a (Maybe a)-    type HmSym0 = Hm-    type MSym3 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: Bool) =-        M a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (MSym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MSym2KindInference) ())-    data MSym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: (~>) Bool Bool-      where-        MSym2KindInference :: forall a0123456789876543210-                                     a0123456789876543210-                                     a0123456789876543210-                                     arg. 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-    instance SuppressUnusedWarnings (MSym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MSym1KindInference) ())-    data MSym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                 (~>) b0123456789876543210 ((~>) Bool Bool)-      where-        MSym1KindInference :: forall a0123456789876543210-                                     a0123456789876543210-                                     arg. SameKind (Apply (MSym1 a0123456789876543210) arg) (MSym2 a0123456789876543210 arg) =>-                              MSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (MSym1 a0123456789876543210) a0123456789876543210 = MSym2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings MSym0 where-      suppressUnusedWarnings = snd (((,) MSym0KindInference) ())-    data MSym0 :: forall a0123456789876543210 b0123456789876543210.-                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) Bool Bool))-      where-        MSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply MSym0 arg) (MSym1 arg) =>-                              MSym0 a0123456789876543210-    type instance Apply MSym0 a0123456789876543210 = MSym1 a0123456789876543210-    type family M (a :: a) (a :: b) (a :: Bool) :: Bool where-      M _ _ x = x-    class PC (a :: GHC.Types.Type) (b :: GHC.Types.Type)-    instance PC Bool Hm-    instance PC a (Maybe a)-    sM ::-      forall a b (t :: a) (t :: b) (t :: Bool).-      Sing t-      -> Sing t-         -> Sing t -> Sing (Apply (Apply (Apply MSym0 t) t) t :: Bool)-    sM _ _ (sX :: Sing x) = sX-    instance SingI (MSym0 :: (~>) a ((~>) b ((~>) Bool Bool))) where-      sing = (singFun3 @MSym0) sM-    instance SingI d =>-             SingI (MSym1 (d :: a) :: (~>) b ((~>) Bool Bool)) where-      sing = (singFun2 @(MSym1 (d :: a))) (sM (sing @d))-    instance (SingI d, SingI d) =>-             SingI (MSym2 (d :: a) (d :: b) :: (~>) Bool Bool) where-      sing-        = (singFun1 @(MSym2 (d :: a) (d :: b))) ((sM (sing @d)) (sing @d))-    data instance Sing :: Hm -> GHC.Types.Type where SHm :: Sing Hm-    type SHm = (Sing :: Hm -> GHC.Types.Type)-    instance SingKind Hm where-      type Demote Hm = Hm-      fromSing SHm = Hm-      toSing Hm = SomeSing SHm-    class SC a b-    instance SC Bool Hm-    instance SC a a => SC a (Maybe a)-    instance SingI Hm where-      sing = SHm
+ tests/compile-and-dump/Singletons/T209.ghc88.template view
@@ -0,0 +1,82 @@+Singletons/T209.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| m :: a -> b -> Bool -> Bool+          m _ _ x = x+          +          class C a b+          data Hm+            = Hm+            deriving anyclass (C Bool)+          +          deriving anyclass instance C a a => C a (Maybe a) |]+  ======>+    class C a b+    m :: a -> b -> Bool -> Bool+    m _ _ x = x+    data Hm+      = Hm+      deriving anyclass (C Bool)+    deriving anyclass instance C a a => C a (Maybe a)+    type HmSym0 = Hm+    type MSym3 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: Bool) =+        M a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (MSym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MSym2KindInference) ())+    data MSym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) :: (~>) Bool Bool+      where+        MSym2KindInference :: forall a0123456789876543210+                                     a0123456789876543210+                                     a0123456789876543210+                                     arg. 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+    instance SuppressUnusedWarnings (MSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MSym1KindInference) ())+    data MSym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                 (~>) b0123456789876543210 ((~>) Bool Bool)+      where+        MSym1KindInference :: forall a0123456789876543210+                                     a0123456789876543210+                                     arg. SameKind (Apply (MSym1 a0123456789876543210) arg) (MSym2 a0123456789876543210 arg) =>+                              MSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (MSym1 a0123456789876543210) a0123456789876543210 = MSym2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings MSym0 where+      suppressUnusedWarnings = snd (((,) MSym0KindInference) ())+    data MSym0 :: forall a0123456789876543210 b0123456789876543210.+                  (~>) a0123456789876543210 ((~>) b0123456789876543210 ((~>) Bool Bool))+      where+        MSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply MSym0 arg) (MSym1 arg) =>+                              MSym0 a0123456789876543210+    type instance Apply MSym0 a0123456789876543210 = MSym1 a0123456789876543210+    type family M (a :: a) (a :: b) (a :: Bool) :: Bool where+      M _ _ x = x+    class PC (a :: GHC.Types.Type) (b :: GHC.Types.Type)+    instance PC Bool Hm+    instance PC a (Maybe a)+    sM ::+      forall a b (t :: a) (t :: b) (t :: Bool).+      Sing t+      -> Sing t+         -> Sing t -> Sing (Apply (Apply (Apply MSym0 t) t) t :: Bool)+    sM _ _ (sX :: Sing x) = sX+    instance SingI (MSym0 :: (~>) a ((~>) b ((~>) Bool Bool))) where+      sing = (singFun3 @MSym0) sM+    instance SingI d =>+             SingI (MSym1 (d :: a) :: (~>) b ((~>) Bool Bool)) where+      sing = (singFun2 @(MSym1 (d :: a))) (sM (sing @d))+    instance (SingI d, SingI d) =>+             SingI (MSym2 (d :: a) (d :: b) :: (~>) Bool Bool) where+      sing+        = (singFun1 @(MSym2 (d :: a) (d :: b))) ((sM (sing @d)) (sing @d))+    data SHm :: Hm -> GHC.Types.Type where SHm :: SHm Hm+    type instance Sing @Hm = SHm+    instance SingKind Hm where+      type Demote Hm = Hm+      fromSing SHm = Hm+      toSing Hm = SomeSing SHm+    class SC a b+    instance SC Bool Hm+    instance SC a a => SC a (Maybe a)+    instance SingI Hm where+      sing = SHm
− tests/compile-and-dump/Singletons/T216.ghc86.template 
@@ -1,56 +0,0 @@-Singletons/T216.hs:0:0:: Splicing declarations-    genDefunSymbols [''MyProxy, ''Symmetry]-  ======>-    type MyProxySym2 (k0123456789876543210 :: Type) (a0123456789876543210 :: k0123456789876543210) =-        MyProxy k0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (MyProxySym1 k0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MyProxySym1KindInference) ())-    data MyProxySym1 (k0123456789876543210 :: Type) :: (~>) k0123456789876543210 Type-      where-        MyProxySym1KindInference :: forall k0123456789876543210-                                           a0123456789876543210-                                           arg. SameKind (Apply (MyProxySym1 k0123456789876543210) arg) (MyProxySym2 k0123456789876543210 arg) =>-                                    MyProxySym1 k0123456789876543210 a0123456789876543210-    type instance Apply (MyProxySym1 k0123456789876543210) a0123456789876543210 = MyProxy k0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings MyProxySym0 where-      suppressUnusedWarnings = snd (((,) MyProxySym0KindInference) ())-    data MyProxySym0 :: forall (k0123456789876543210 :: Type).-                        (~>) Type ((~>) k0123456789876543210 Type)-      where-        MyProxySym0KindInference :: forall k0123456789876543210-                                           arg. SameKind (Apply MyProxySym0 arg) (MyProxySym1 arg) =>-                                    MyProxySym0 k0123456789876543210-    type instance Apply MyProxySym0 k0123456789876543210 = MyProxySym1 k0123456789876543210-    type SymmetrySym3 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) (e0123456789876543210 :: (:~:) a0123456789876543210 y0123456789876543210) =-        Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210-    instance SuppressUnusedWarnings (SymmetrySym2 y0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) SymmetrySym2KindInference) ())-    data SymmetrySym2 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) :: (~>) ((:~:) a0123456789876543210 y0123456789876543210) Type-      where-        SymmetrySym2KindInference :: forall a0123456789876543210-                                            y0123456789876543210-                                            e0123456789876543210-                                            arg. SameKind (Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) arg) (SymmetrySym3 a0123456789876543210 y0123456789876543210 arg) =>-                                     SymmetrySym2 a0123456789876543210 y0123456789876543210 e0123456789876543210-    type instance Apply (SymmetrySym2 y0123456789876543210 a0123456789876543210) e0123456789876543210 = Symmetry y0123456789876543210 a0123456789876543210 e0123456789876543210-    instance SuppressUnusedWarnings (SymmetrySym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) SymmetrySym1KindInference) ())-    data SymmetrySym1 (a0123456789876543210 :: t0123456789876543210) :: forall (y0123456789876543210 :: t0123456789876543210).-                                                                        (~>) t0123456789876543210 ((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type)-      where-        SymmetrySym1KindInference :: forall a0123456789876543210-                                            y0123456789876543210-                                            arg. SameKind (Apply (SymmetrySym1 a0123456789876543210) arg) (SymmetrySym2 a0123456789876543210 arg) =>-                                     SymmetrySym1 a0123456789876543210 y0123456789876543210-    type instance Apply (SymmetrySym1 a0123456789876543210) y0123456789876543210 = SymmetrySym2 a0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings SymmetrySym0 where-      suppressUnusedWarnings = snd (((,) SymmetrySym0KindInference) ())-    data SymmetrySym0 :: forall t0123456789876543210-                                (a0123456789876543210 :: t0123456789876543210)-                                (y0123456789876543210 :: t0123456789876543210).-                         (~>) t0123456789876543210 ((~>) t0123456789876543210 ((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type))-      where-        SymmetrySym0KindInference :: forall a0123456789876543210-                                            arg. SameKind (Apply SymmetrySym0 arg) (SymmetrySym1 arg) =>-                                     SymmetrySym0 a0123456789876543210-    type instance Apply SymmetrySym0 a0123456789876543210 = SymmetrySym1 a0123456789876543210
+ tests/compile-and-dump/Singletons/T216.ghc88.template view
@@ -0,0 +1,56 @@+Singletons/T216.hs:0:0:: Splicing declarations+    genDefunSymbols [''MyProxy, ''Symmetry]+  ======>+    type MyProxySym2 (k0123456789876543210 :: Type) (a0123456789876543210 :: k0123456789876543210) =+        MyProxy k0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (MyProxySym1 k0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MyProxySym1KindInference) ())+    data MyProxySym1 (k0123456789876543210 :: Type) :: (~>) k0123456789876543210 Type+      where+        MyProxySym1KindInference :: forall k0123456789876543210+                                           a0123456789876543210+                                           arg. SameKind (Apply (MyProxySym1 k0123456789876543210) arg) (MyProxySym2 k0123456789876543210 arg) =>+                                    MyProxySym1 k0123456789876543210 a0123456789876543210+    type instance Apply (MyProxySym1 k0123456789876543210) a0123456789876543210 = MyProxy k0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings MyProxySym0 where+      suppressUnusedWarnings = snd (((,) MyProxySym0KindInference) ())+    data MyProxySym0 :: forall (k0123456789876543210 :: Type).+                        (~>) Type ((~>) k0123456789876543210 Type)+      where+        MyProxySym0KindInference :: forall k0123456789876543210+                                           arg. SameKind (Apply MyProxySym0 arg) (MyProxySym1 arg) =>+                                    MyProxySym0 k0123456789876543210+    type instance Apply MyProxySym0 k0123456789876543210 = MyProxySym1 k0123456789876543210+    type SymmetrySym3 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) (e0123456789876543210 :: (:~:) a0123456789876543210 y0123456789876543210) =+        Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210+    instance SuppressUnusedWarnings (SymmetrySym2 y0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) SymmetrySym2KindInference) ())+    data SymmetrySym2 (a0123456789876543210 :: t0123456789876543210) (y0123456789876543210 :: t0123456789876543210) :: (~>) ((:~:) a0123456789876543210 y0123456789876543210) Type+      where+        SymmetrySym2KindInference :: forall a0123456789876543210+                                            y0123456789876543210+                                            e0123456789876543210+                                            arg. SameKind (Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) arg) (SymmetrySym3 a0123456789876543210 y0123456789876543210 arg) =>+                                     SymmetrySym2 a0123456789876543210 y0123456789876543210 e0123456789876543210+    type instance Apply (SymmetrySym2 y0123456789876543210 a0123456789876543210) e0123456789876543210 = Symmetry y0123456789876543210 a0123456789876543210 e0123456789876543210+    instance SuppressUnusedWarnings (SymmetrySym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) SymmetrySym1KindInference) ())+    data SymmetrySym1 (a0123456789876543210 :: t0123456789876543210) :: forall (y0123456789876543210 :: t0123456789876543210).+                                                                        (~>) t0123456789876543210 ((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type)+      where+        SymmetrySym1KindInference :: forall a0123456789876543210+                                            y0123456789876543210+                                            arg. SameKind (Apply (SymmetrySym1 a0123456789876543210) arg) (SymmetrySym2 a0123456789876543210 arg) =>+                                     SymmetrySym1 a0123456789876543210 y0123456789876543210+    type instance Apply (SymmetrySym1 a0123456789876543210) y0123456789876543210 = SymmetrySym2 a0123456789876543210 y0123456789876543210+    instance SuppressUnusedWarnings SymmetrySym0 where+      suppressUnusedWarnings = snd (((,) SymmetrySym0KindInference) ())+    data SymmetrySym0 :: forall t0123456789876543210+                                (a0123456789876543210 :: t0123456789876543210)+                                (y0123456789876543210 :: t0123456789876543210).+                         (~>) t0123456789876543210 ((~>) t0123456789876543210 ((~>) ((:~:) a0123456789876543210 y0123456789876543210) Type))+      where+        SymmetrySym0KindInference :: forall a0123456789876543210+                                            arg. SameKind (Apply SymmetrySym0 arg) (SymmetrySym1 arg) =>+                                     SymmetrySym0 a0123456789876543210+    type instance Apply SymmetrySym0 a0123456789876543210 = SymmetrySym1 a0123456789876543210
− tests/compile-and-dump/Singletons/T226.ghc86.template 
@@ -1,6 +0,0 @@-Singletons/T226.hs:0:0:: Splicing declarations-    singletons [d| class a ~> b |]-  ======>-    class (~>) a b-    class (#~>) (a :: GHC.Types.Type) (b :: GHC.Types.Type)-    class (%~>) a b
+ tests/compile-and-dump/Singletons/T226.ghc88.template view
@@ -0,0 +1,6 @@+Singletons/T226.hs:0:0:: Splicing declarations+    singletons [d| class a ~> b |]+  ======>+    class (~>) a b+    class (#~>) (a :: GHC.Types.Type) (b :: GHC.Types.Type)+    class (%~>) a b
− tests/compile-and-dump/Singletons/T229.ghc86.template 
@@ -1,24 +0,0 @@-Singletons/T229.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| ___foo :: Bool -> Bool-          ___foo _ = True |]-  ======>-    ___foo :: Bool -> Bool-    ___foo _ = True-    type US___fooSym1 (a0123456789876543210 :: Bool) =-        US___foo a0123456789876543210-    instance SuppressUnusedWarnings US___fooSym0 where-      suppressUnusedWarnings = snd (((,) US___fooSym0KindInference) ())-    data US___fooSym0 :: (~>) Bool Bool-      where-        US___fooSym0KindInference :: forall a0123456789876543210-                                            arg. SameKind (Apply US___fooSym0 arg) (US___fooSym1 arg) =>-                                     US___fooSym0 a0123456789876543210-    type instance Apply US___fooSym0 a0123456789876543210 = US___foo a0123456789876543210-    type family US___foo (a :: Bool) :: Bool where-      US___foo _ = TrueSym0-    ___sfoo ::-      forall (t :: Bool). Sing t -> Sing (Apply US___fooSym0 t :: Bool)-    ___sfoo _ = STrue-    instance SingI (US___fooSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @US___fooSym0) ___sfoo
+ tests/compile-and-dump/Singletons/T229.ghc88.template view
@@ -0,0 +1,24 @@+Singletons/T229.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| ___foo :: Bool -> Bool+          ___foo _ = True |]+  ======>+    ___foo :: Bool -> Bool+    ___foo _ = True+    type US___fooSym1 (a0123456789876543210 :: Bool) =+        US___foo a0123456789876543210+    instance SuppressUnusedWarnings US___fooSym0 where+      suppressUnusedWarnings = snd (((,) US___fooSym0KindInference) ())+    data US___fooSym0 :: (~>) Bool Bool+      where+        US___fooSym0KindInference :: forall a0123456789876543210+                                            arg. SameKind (Apply US___fooSym0 arg) (US___fooSym1 arg) =>+                                     US___fooSym0 a0123456789876543210+    type instance Apply US___fooSym0 a0123456789876543210 = US___foo a0123456789876543210+    type family US___foo (a :: Bool) :: Bool where+      US___foo _ = TrueSym0+    ___sfoo ::+      forall (t :: Bool). Sing t -> Sing (Apply US___fooSym0 t :: Bool)+    ___sfoo _ = STrue+    instance SingI (US___fooSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @US___fooSym0) ___sfoo
− tests/compile-and-dump/Singletons/T249.ghc86.template 
@@ -1,90 +0,0 @@-Singletons/T249.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Foo1 a = MkFoo1 a-          data Foo2 a where MkFoo2 :: x -> Foo2 x-          data Foo3 a where MkFoo3 :: forall x. x -> Foo3 x |]-  ======>-    data Foo1 a = MkFoo1 a-    data Foo2 a where MkFoo2 :: x -> Foo2 x-    data Foo3 a where MkFoo3 :: forall x. x -> Foo3 x-    type MkFoo1Sym1 (t0123456789876543210 :: a0123456789876543210) =-        MkFoo1 t0123456789876543210-    instance SuppressUnusedWarnings MkFoo1Sym0 where-      suppressUnusedWarnings = snd (((,) MkFoo1Sym0KindInference) ())-    data MkFoo1Sym0 :: forall a0123456789876543210.-                       (~>) a0123456789876543210 (Foo1 a0123456789876543210)-      where-        MkFoo1Sym0KindInference :: forall t0123456789876543210-                                          arg. SameKind (Apply MkFoo1Sym0 arg) (MkFoo1Sym1 arg) =>-                                   MkFoo1Sym0 t0123456789876543210-    type instance Apply MkFoo1Sym0 t0123456789876543210 = MkFoo1 t0123456789876543210-    type MkFoo2Sym1 (t0123456789876543210 :: x0123456789876543210) =-        MkFoo2 t0123456789876543210-    instance SuppressUnusedWarnings MkFoo2Sym0 where-      suppressUnusedWarnings = snd (((,) MkFoo2Sym0KindInference) ())-    data MkFoo2Sym0 :: forall x0123456789876543210.-                       (~>) x0123456789876543210 (Foo2 x0123456789876543210)-      where-        MkFoo2Sym0KindInference :: forall t0123456789876543210-                                          arg. SameKind (Apply MkFoo2Sym0 arg) (MkFoo2Sym1 arg) =>-                                   MkFoo2Sym0 t0123456789876543210-    type instance Apply MkFoo2Sym0 t0123456789876543210 = MkFoo2 t0123456789876543210-    type MkFoo3Sym1 (t0123456789876543210 :: x0123456789876543210) =-        MkFoo3 t0123456789876543210-    instance SuppressUnusedWarnings MkFoo3Sym0 where-      suppressUnusedWarnings = snd (((,) MkFoo3Sym0KindInference) ())-    data MkFoo3Sym0 :: forall x0123456789876543210.-                       (~>) x0123456789876543210 (Foo3 x0123456789876543210)-      where-        MkFoo3Sym0KindInference :: forall t0123456789876543210-                                          arg. SameKind (Apply MkFoo3Sym0 arg) (MkFoo3Sym1 arg) =>-                                   MkFoo3Sym0 t0123456789876543210-    type instance Apply MkFoo3Sym0 t0123456789876543210 = MkFoo3 t0123456789876543210-    data instance Sing :: Foo1 a -> Type-      where-        SMkFoo1 :: forall a (n :: a). (Sing (n :: a)) -> Sing (MkFoo1 n)-    type SFoo1 = (Sing :: Foo1 a -> Type)-    instance SingKind a => SingKind (Foo1 a) where-      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) }-    data instance Sing :: Foo2 a -> Type-      where-        SMkFoo2 :: forall x (n :: x). (Sing (n :: x)) -> Sing (MkFoo2 n)-    type SFoo2 = (Sing :: Foo2 a -> Type)-    instance SingKind a => SingKind (Foo2 a) where-      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) }-    data instance Sing :: Foo3 a -> Type-      where-        SMkFoo3 :: forall x (n :: x). (Sing (n :: x)) -> Sing (MkFoo3 n)-    type SFoo3 = (Sing :: Foo3 a -> Type)-    instance SingKind a => SingKind (Foo3 a) where-      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) }-    instance SingI n => SingI (MkFoo1 (n :: a)) where-      sing = SMkFoo1 sing-    instance SingI (MkFoo1Sym0 :: (~>) a (Foo1 a)) where-      sing = (singFun1 @MkFoo1Sym0) SMkFoo1-    instance SingI (TyCon1 MkFoo1 :: (~>) a (Foo1 a)) where-      sing = (singFun1 @(TyCon1 MkFoo1)) SMkFoo1-    instance SingI n => SingI (MkFoo2 (n :: x)) where-      sing = SMkFoo2 sing-    instance SingI (MkFoo2Sym0 :: (~>) x (Foo2 x)) where-      sing = (singFun1 @MkFoo2Sym0) SMkFoo2-    instance SingI (TyCon1 MkFoo2 :: (~>) x (Foo2 x)) where-      sing = (singFun1 @(TyCon1 MkFoo2)) SMkFoo2-    instance SingI n => SingI (MkFoo3 (n :: x)) where-      sing = SMkFoo3 sing-    instance SingI (MkFoo3Sym0 :: (~>) x (Foo3 x)) where-      sing = (singFun1 @MkFoo3Sym0) SMkFoo3-    instance SingI (TyCon1 MkFoo3 :: (~>) x (Foo3 x)) where-      sing = (singFun1 @(TyCon1 MkFoo3)) SMkFoo3
+ tests/compile-and-dump/Singletons/T249.ghc88.template view
@@ -0,0 +1,84 @@+Singletons/T249.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Foo1 a = MkFoo1 a+          data Foo2 a where MkFoo2 :: x -> Foo2 x+          data Foo3 a where MkFoo3 :: forall x. x -> Foo3 x |]+  ======>+    data Foo1 a = MkFoo1 a+    data Foo2 a where MkFoo2 :: x -> Foo2 x+    data Foo3 a where MkFoo3 :: forall x. x -> Foo3 x+    type MkFoo1Sym1 (t0123456789876543210 :: a0123456789876543210) =+        MkFoo1 t0123456789876543210+    instance SuppressUnusedWarnings MkFoo1Sym0 where+      suppressUnusedWarnings = snd (((,) MkFoo1Sym0KindInference) ())+    data MkFoo1Sym0 :: forall a0123456789876543210.+                       (~>) a0123456789876543210 (Foo1 a0123456789876543210)+      where+        MkFoo1Sym0KindInference :: forall t0123456789876543210+                                          arg. SameKind (Apply MkFoo1Sym0 arg) (MkFoo1Sym1 arg) =>+                                   MkFoo1Sym0 t0123456789876543210+    type instance Apply MkFoo1Sym0 t0123456789876543210 = MkFoo1 t0123456789876543210+    type MkFoo2Sym1 (t0123456789876543210 :: x0123456789876543210) =+        MkFoo2 t0123456789876543210+    instance SuppressUnusedWarnings MkFoo2Sym0 where+      suppressUnusedWarnings = snd (((,) MkFoo2Sym0KindInference) ())+    data MkFoo2Sym0 :: forall x0123456789876543210.+                       (~>) x0123456789876543210 (Foo2 x0123456789876543210)+      where+        MkFoo2Sym0KindInference :: forall t0123456789876543210+                                          arg. SameKind (Apply MkFoo2Sym0 arg) (MkFoo2Sym1 arg) =>+                                   MkFoo2Sym0 t0123456789876543210+    type instance Apply MkFoo2Sym0 t0123456789876543210 = MkFoo2 t0123456789876543210+    type MkFoo3Sym1 (t0123456789876543210 :: x0123456789876543210) =+        MkFoo3 t0123456789876543210+    instance SuppressUnusedWarnings MkFoo3Sym0 where+      suppressUnusedWarnings = snd (((,) MkFoo3Sym0KindInference) ())+    data MkFoo3Sym0 :: forall x0123456789876543210.+                       (~>) x0123456789876543210 (Foo3 x0123456789876543210)+      where+        MkFoo3Sym0KindInference :: forall t0123456789876543210+                                          arg. SameKind (Apply MkFoo3Sym0 arg) (MkFoo3Sym1 arg) =>+                                   MkFoo3Sym0 t0123456789876543210+    type instance Apply MkFoo3Sym0 t0123456789876543210 = MkFoo3 t0123456789876543210+    data SFoo1 :: forall a. Foo1 a -> Type+      where+        SMkFoo1 :: forall a (n :: a). (Sing (n :: a)) -> SFoo1 (MkFoo1 n)+    type instance Sing @(Foo1 a) = SFoo1+    instance SingKind a => SingKind (Foo1 a) where+      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) }+    data SFoo2 :: forall a. Foo2 a -> Type+      where+        SMkFoo2 :: forall x (n :: x). (Sing (n :: x)) -> SFoo2 (MkFoo2 n)+    type instance Sing @(Foo2 a) = SFoo2+    instance SingKind a => SingKind (Foo2 a) where+      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) }+    data SFoo3 :: forall a. Foo3 a -> Type+      where+        SMkFoo3 :: forall x (n :: x). (Sing (n :: x)) -> SFoo3 (MkFoo3 n)+    type instance Sing @(Foo3 a) = SFoo3+    instance SingKind a => SingKind (Foo3 a) where+      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) }+    instance SingI n => SingI (MkFoo1 (n :: a)) where+      sing = SMkFoo1 sing+    instance SingI (MkFoo1Sym0 :: (~>) a (Foo1 a)) where+      sing = (singFun1 @MkFoo1Sym0) SMkFoo1+    instance SingI n => SingI (MkFoo2 (n :: x)) where+      sing = SMkFoo2 sing+    instance SingI (MkFoo2Sym0 :: (~>) x (Foo2 x)) where+      sing = (singFun1 @MkFoo2Sym0) SMkFoo2+    instance SingI n => SingI (MkFoo3 (n :: x)) where+      sing = SMkFoo3 sing+    instance SingI (MkFoo3Sym0 :: (~>) x (Foo3 x)) where+      sing = (singFun1 @MkFoo3Sym0) SMkFoo3
− tests/compile-and-dump/Singletons/T271.ghc86.template 
@@ -1,199 +0,0 @@-Singletons/T271.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| newtype Constant (a :: Type) (b :: Type)-            = Constant a-            deriving (Eq, Ord)-          data Identity :: Type -> Type-            where Identity :: a -> Identity a-            deriving (Eq, Ord) |]-  ======>-    newtype Constant (a :: Type) (b :: Type)-      = Constant a-      deriving (Eq, Ord)-    data Identity :: Type -> Type-      where Identity :: a -> Identity a-      deriving (Eq, Ord)-    type ConstantSym1 (t0123456789876543210 :: a0123456789876543210) =-        Constant t0123456789876543210-    instance SuppressUnusedWarnings ConstantSym0 where-      suppressUnusedWarnings = snd (((,) ConstantSym0KindInference) ())-    data ConstantSym0 :: forall (a0123456789876543210 :: Type)-                                (b0123456789876543210 :: Type).-                         (~>) a0123456789876543210 (Constant (a0123456789876543210 :: Type) (b0123456789876543210 :: Type))-      where-        ConstantSym0KindInference :: forall t0123456789876543210-                                            arg. SameKind (Apply ConstantSym0 arg) (ConstantSym1 arg) =>-                                     ConstantSym0 t0123456789876543210-    type instance Apply ConstantSym0 t0123456789876543210 = Constant t0123456789876543210-    type IdentitySym1 (t0123456789876543210 :: a0123456789876543210) =-        Identity t0123456789876543210-    instance SuppressUnusedWarnings IdentitySym0 where-      suppressUnusedWarnings = snd (((,) IdentitySym0KindInference) ())-    data IdentitySym0 :: forall a0123456789876543210.-                         (~>) a0123456789876543210 (Identity a0123456789876543210)-      where-        IdentitySym0KindInference :: forall t0123456789876543210-                                            arg. SameKind (Apply IdentitySym0 arg) (IdentitySym1 arg) =>-                                     IdentitySym0 t0123456789876543210-    type instance Apply IdentitySym0 t0123456789876543210 = Identity t0123456789876543210-    type family Compare_0123456789876543210 (a :: Constant a b) (a :: Constant a b) :: Ordering where-      Compare_0123456789876543210 (Constant a_0123456789876543210) (Constant b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Constant a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Constant a0123456789876543210 b0123456789876543210) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Constant a0123456789876543210 b0123456789876543210) :: (~>) (Constant a0123456789876543210 b0123456789876543210) Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: forall a0123456789876543210-                                                   b0123456789876543210.-                                            (~>) (Constant a0123456789876543210 b0123456789876543210) ((~>) (Constant a0123456789876543210 b0123456789876543210) Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd (Constant a b) where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Compare_0123456789876543210 (a :: Identity a) (a :: Identity a) :: Ordering where-      Compare_0123456789876543210 (Identity a_0123456789876543210) (Identity b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])-    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Identity a0123456789876543210) (a0123456789876543210 :: Identity a0123456789876543210) =-        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())-    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Identity a0123456789876543210) :: (~>) (Identity a0123456789876543210) Ordering-      where-        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                               a0123456789876543210-                                                               arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())-    data Compare_0123456789876543210Sym0 :: forall a0123456789876543210.-                                            (~>) (Identity a0123456789876543210) ((~>) (Identity a0123456789876543210) Ordering)-      where-        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>-                                                        Compare_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210-    instance POrd (Identity a) where-      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a-    type family Equals_0123456789876543210 (a :: Constant a b) (b :: Constant a b) :: Bool where-      Equals_0123456789876543210 (Constant a) (Constant b) = (==) a b-      Equals_0123456789876543210 (_ :: Constant a b) (_ :: Constant a b) = FalseSym0-    instance PEq (Constant a b) where-      type (==) a b = Equals_0123456789876543210 a b-    type family Equals_0123456789876543210 (a :: Identity a) (b :: Identity a) :: Bool where-      Equals_0123456789876543210 (Identity a) (Identity b) = (==) a b-      Equals_0123456789876543210 (_ :: Identity a) (_ :: Identity a) = FalseSym0-    instance PEq (Identity a) where-      type (==) a b = Equals_0123456789876543210 a b-    data instance Sing :: Constant a b -> Type-      where-        SConstant :: forall a (n :: a).-                     (Sing (n :: a)) -> Sing (Constant n)-    type SConstant = (Sing :: Constant a b -> Type)-    instance (SingKind a, SingKind b) => SingKind (Constant a b) where-      type Demote (Constant a b) = Constant (Demote a) (Demote b)-      fromSing (SConstant b) = Constant (fromSing b)-      toSing (Constant (b :: Demote a))-        = case toSing b :: SomeSing a of {-            SomeSing c -> SomeSing (SConstant c) }-    data instance Sing :: Identity a -> Type-      where-        SIdentity :: forall a (n :: a).-                     (Sing (n :: a)) -> Sing (Identity n)-    type SIdentity = (Sing :: Identity a -> Type)-    instance SingKind a => SingKind (Identity a) where-      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) }-    instance SOrd a => SOrd (Constant a b) where-      sCompare ::-        forall (t1 :: Constant a b) (t2 :: Constant a b).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun (Constant a b) ((~>) (Constant a b) Ordering)-                                                 -> Type) t1) t2)-      sCompare-        (SConstant (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SConstant (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing-                    ((singFun2 @(:@#@$))-                       Data.Singletons.Prelude.Instances.SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               Data.Singletons.Prelude.Instances.SNil)-    instance SOrd a => SOrd (Identity a) where-      sCompare ::-        forall (t1 :: Identity a) (t2 :: Identity a).-        Sing t1-        -> Sing t2-           -> Sing (Apply (Apply (CompareSym0 :: TyFun (Identity a) ((~>) (Identity a) Ordering)-                                                 -> Type) t1) t2)-      sCompare-        (SIdentity (sA_0123456789876543210 :: Sing a_0123456789876543210))-        (SIdentity (sB_0123456789876543210 :: Sing b_0123456789876543210))-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @FoldlSym0) sFoldl))-                    ((singFun2 @ThenCmpSym0) sThenCmp)))-                SEQ))-            ((applySing-                ((applySing-                    ((singFun2 @(:@#@$))-                       Data.Singletons.Prelude.Instances.SCons))-                   ((applySing-                       ((applySing ((singFun2 @CompareSym0) sCompare))-                          sA_0123456789876543210))-                      sB_0123456789876543210)))-               Data.Singletons.Prelude.Instances.SNil)-    instance SEq a => SEq (Constant a b) where-      (%==) (SConstant a) (SConstant b) = ((%==) a) b-    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 })-    instance SEq a => SEq (Identity a) where-      (%==) (SIdentity a) (SIdentity b) = ((%==) a) b-    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 })-    instance SingI n => SingI (Constant (n :: a)) where-      sing = SConstant sing-    instance SingI (ConstantSym0 :: (~>) a (Constant (a :: Type) (b :: Type))) where-      sing = (singFun1 @ConstantSym0) SConstant-    instance SingI (TyCon1 Constant :: (~>) a (Constant (a :: Type) (b :: Type))) where-      sing = (singFun1 @(TyCon1 Constant)) SConstant-    instance SingI n => SingI (Identity (n :: a)) where-      sing = SIdentity sing-    instance SingI (IdentitySym0 :: (~>) a (Identity a)) where-      sing = (singFun1 @IdentitySym0) SIdentity-    instance SingI (TyCon1 Identity :: (~>) a (Identity a)) where-      sing = (singFun1 @(TyCon1 Identity)) SIdentity
+ tests/compile-and-dump/Singletons/T271.ghc88.template view
@@ -0,0 +1,215 @@+Singletons/T271.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| newtype Constant (a :: Type) (b :: Type)+            = Constant a+            deriving (Eq, Ord)+          data Identity :: Type -> Type+            where Identity :: a -> Identity a+            deriving (Eq, Ord) |]+  ======>+    newtype Constant (a :: Type) (b :: Type)+      = Constant a+      deriving (Eq, Ord)+    data Identity :: Type -> Type+      where Identity :: a -> Identity a+      deriving (Eq, Ord)+    type ConstantSym1 (t0123456789876543210 :: a0123456789876543210) =+        Constant t0123456789876543210+    instance SuppressUnusedWarnings ConstantSym0 where+      suppressUnusedWarnings = snd (((,) ConstantSym0KindInference) ())+    data ConstantSym0 :: forall (a0123456789876543210 :: Type)+                                (b0123456789876543210 :: Type).+                         (~>) a0123456789876543210 (Constant (a0123456789876543210 :: Type) (b0123456789876543210 :: Type))+      where+        ConstantSym0KindInference :: forall t0123456789876543210+                                            arg. SameKind (Apply ConstantSym0 arg) (ConstantSym1 arg) =>+                                     ConstantSym0 t0123456789876543210+    type instance Apply ConstantSym0 t0123456789876543210 = Constant t0123456789876543210+    type IdentitySym1 (t0123456789876543210 :: a0123456789876543210) =+        Identity t0123456789876543210+    instance SuppressUnusedWarnings IdentitySym0 where+      suppressUnusedWarnings = snd (((,) IdentitySym0KindInference) ())+    data IdentitySym0 :: forall a0123456789876543210.+                         (~>) a0123456789876543210 (Identity a0123456789876543210)+      where+        IdentitySym0KindInference :: forall t0123456789876543210+                                            arg. SameKind (Apply IdentitySym0 arg) (IdentitySym1 arg) =>+                                     IdentitySym0 t0123456789876543210+    type instance Apply IdentitySym0 t0123456789876543210 = Identity t0123456789876543210+    type family Compare_0123456789876543210 (a :: Constant a b) (a :: Constant a b) :: Ordering where+      Compare_0123456789876543210 (Constant a_0123456789876543210) (Constant b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Constant a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Constant a0123456789876543210 b0123456789876543210) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Constant a0123456789876543210 b0123456789876543210) :: (~>) (Constant a0123456789876543210 b0123456789876543210) Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: forall a0123456789876543210+                                                   b0123456789876543210.+                                            (~>) (Constant a0123456789876543210 b0123456789876543210) ((~>) (Constant a0123456789876543210 b0123456789876543210) Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd (Constant a b) where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family Compare_0123456789876543210 (a :: Identity a) (a :: Identity a) :: Ordering where+      Compare_0123456789876543210 (Identity a_0123456789876543210) (Identity b_0123456789876543210) = Apply (Apply (Apply FoldlSym0 ThenCmpSym0) EQSym0) (Apply (Apply (:@#@$) (Apply (Apply CompareSym0 a_0123456789876543210) b_0123456789876543210)) '[])+    type Compare_0123456789876543210Sym2 (a0123456789876543210 :: Identity a0123456789876543210) (a0123456789876543210 :: Identity a0123456789876543210) =+        Compare_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Compare_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym1KindInference) ())+    data Compare_0123456789876543210Sym1 (a0123456789876543210 :: Identity a0123456789876543210) :: (~>) (Identity a0123456789876543210) Ordering+      where+        Compare_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                               a0123456789876543210+                                                               arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Compare_0123456789876543210Sym0KindInference) ())+    data Compare_0123456789876543210Sym0 :: forall a0123456789876543210.+                                            (~>) (Identity a0123456789876543210) ((~>) (Identity a0123456789876543210) Ordering)+      where+        Compare_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                               arg. SameKind (Apply Compare_0123456789876543210Sym0 arg) (Compare_0123456789876543210Sym1 arg) =>+                                                        Compare_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Compare_0123456789876543210Sym0 a0123456789876543210 = Compare_0123456789876543210Sym1 a0123456789876543210+    instance POrd (Identity a) where+      type Compare a a = Apply (Apply Compare_0123456789876543210Sym0 a) a+    type family Equals_0123456789876543210 (a :: Constant a b) (b :: Constant a b) :: Bool where+      Equals_0123456789876543210 (Constant a) (Constant b) = (==) a b+      Equals_0123456789876543210 (_ :: Constant a b) (_ :: Constant a b) = FalseSym0+    instance PEq (Constant a b) where+      type (==) a b = Equals_0123456789876543210 a b+    type family Equals_0123456789876543210 (a :: Identity a) (b :: Identity a) :: Bool where+      Equals_0123456789876543210 (Identity a) (Identity b) = (==) a b+      Equals_0123456789876543210 (_ :: Identity a) (_ :: Identity a) = FalseSym0+    instance PEq (Identity a) where+      type (==) a b = Equals_0123456789876543210 a b+    data SConstant :: forall a b. Constant a b -> Type+      where+        SConstant :: forall a (n :: a).+                     (Sing (n :: a)) -> SConstant (Constant n)+    type instance Sing @(Constant a b) = SConstant+    instance (SingKind a, SingKind b) => SingKind (Constant a b) where+      type Demote (Constant a b) = Constant (Demote a) (Demote b)+      fromSing (SConstant b) = Constant (fromSing b)+      toSing (Constant (b :: Demote a))+        = case toSing b :: SomeSing a of {+            SomeSing c -> SomeSing (SConstant c) }+    data SIdentity :: forall a. Identity a -> Type+      where+        SIdentity :: forall a (n :: a).+                     (Sing (n :: a)) -> SIdentity (Identity n)+    type instance Sing @(Identity a) = SIdentity+    instance SingKind a => SingKind (Identity a) where+      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) }+    instance SOrd a => SOrd (Constant a b) where+      sCompare ::+        forall (t1 :: Constant a b) (t2 :: Constant a b).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun (Constant a b) ((~>) (Constant a b) Ordering)+                                                 -> Type) t1) t2)+      sCompare+        (SConstant (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SConstant (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing+                    ((singFun2 @(:@#@$))+                       Data.Singletons.Prelude.Instances.SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               Data.Singletons.Prelude.Instances.SNil)+    instance SOrd a => SOrd (Identity a) where+      sCompare ::+        forall (t1 :: Identity a) (t2 :: Identity a).+        Sing t1+        -> Sing t2+           -> Sing (Apply (Apply (CompareSym0 :: TyFun (Identity a) ((~>) (Identity a) Ordering)+                                                 -> Type) t1) t2)+      sCompare+        (SIdentity (sA_0123456789876543210 :: Sing a_0123456789876543210))+        (SIdentity (sB_0123456789876543210 :: Sing b_0123456789876543210))+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @FoldlSym0) sFoldl))+                    ((singFun2 @ThenCmpSym0) sThenCmp)))+                SEQ))+            ((applySing+                ((applySing+                    ((singFun2 @(:@#@$))+                       Data.Singletons.Prelude.Instances.SCons))+                   ((applySing+                       ((applySing ((singFun2 @CompareSym0) sCompare))+                          sA_0123456789876543210))+                      sB_0123456789876543210)))+               Data.Singletons.Prelude.Instances.SNil)+    instance SEq a => SEq (Constant a b) where+      (%==) (SConstant a) (SConstant b) = ((%==) a) b+    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 })+    instance SDecide a =>+             Data.Type.Equality.TestEquality (SConstant :: Constant a b+                                                           -> Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance SDecide a =>+             Data.Type.Coercion.TestCoercion (SConstant :: Constant a b+                                                           -> Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance SEq a => SEq (Identity a) where+      (%==) (SIdentity a) (SIdentity b) = ((%==) a) b+    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 })+    instance SDecide a =>+             Data.Type.Equality.TestEquality (SIdentity :: Identity a+                                                           -> Type) where+      Data.Type.Equality.testEquality+        = Data.Singletons.Decide.decideEquality+    instance SDecide a =>+             Data.Type.Coercion.TestCoercion (SIdentity :: Identity a+                                                           -> Type) where+      Data.Type.Coercion.testCoercion+        = Data.Singletons.Decide.decideCoercion+    instance SingI n => SingI (Constant (n :: a)) where+      sing = SConstant sing+    instance SingI (ConstantSym0 :: (~>) a (Constant (a :: Type) (b :: Type))) where+      sing = (singFun1 @ConstantSym0) SConstant+    instance SingI n => SingI (Identity (n :: a)) where+      sing = SIdentity sing+    instance SingI (IdentitySym0 :: (~>) a (Identity a)) where+      sing = (singFun1 @IdentitySym0) SIdentity
− tests/compile-and-dump/Singletons/T287.ghc86.template 
@@ -1,116 +0,0 @@-Singletons/T287.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| class S a where-            (<<>>) :: a -> a -> a-          -          instance S b => S (a -> b) where-            f <<>> g = \ x -> f x <<>> g x |]-  ======>-    class S a where-      (<<>>) :: a -> a -> a-    instance S b => S (a -> b) where-      (<<>>) f g = \ x -> (f x <<>> g x)-    type (<<>>@#@$$$) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =-        (<<>>) arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings ((<<>>@#@$$) arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:<<>>@#@$$###)) ())-    data (<<>>@#@$$) (arg0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 a0123456789876543210-      where-        (:<<>>@#@$$###) :: forall arg0123456789876543210-                                  arg0123456789876543210-                                  arg. SameKind (Apply ((<<>>@#@$$) arg0123456789876543210) arg) ((<<>>@#@$$$) arg0123456789876543210 arg) =>-                           (<<>>@#@$$) arg0123456789876543210 arg0123456789876543210-    type instance Apply ((<<>>@#@$$) arg0123456789876543210) arg0123456789876543210 = (<<>>) arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (<<>>@#@$) where-      suppressUnusedWarnings = snd (((,) (:<<>>@#@$###)) ())-    data (<<>>@#@$) :: forall a0123456789876543210.-                       (~>) a0123456789876543210 ((~>) a0123456789876543210 a0123456789876543210)-      where-        (:<<>>@#@$###) :: forall arg0123456789876543210-                                 arg. SameKind (Apply (<<>>@#@$) arg) ((<<>>@#@$$) arg) =>-                          (<<>>@#@$) arg0123456789876543210-    type instance Apply (<<>>@#@$) arg0123456789876543210 = (<<>>@#@$$) arg0123456789876543210-    class PS (a :: GHC.Types.Type) where-      type (<<>>) (arg :: a) (arg :: a) :: a-    type family Lambda_0123456789876543210 f g t where-      Lambda_0123456789876543210 f g x = Apply (Apply (<<>>@#@$) (Apply f x)) (Apply g x)-    type Lambda_0123456789876543210Sym3 f0123456789876543210 g0123456789876543210 t0123456789876543210 =-        Lambda_0123456789876543210 f0123456789876543210 g0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 g0123456789876543210 f0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())-    data Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210 t0123456789876543210-      where-        Lambda_0123456789876543210Sym2KindInference :: forall f0123456789876543210-                                                              g0123456789876543210-                                                              t0123456789876543210-                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210) arg) (Lambda_0123456789876543210Sym3 f0123456789876543210 g0123456789876543210 arg) =>-                                                       Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210 t0123456789876543210-    type instance Apply (Lambda_0123456789876543210Sym2 g0123456789876543210 f0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 g0123456789876543210 f0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 f0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())-    data Lambda_0123456789876543210Sym1 f0123456789876543210 g0123456789876543210-      where-        Lambda_0123456789876543210Sym1KindInference :: forall f0123456789876543210-                                                              g0123456789876543210-                                                              arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())-    data Lambda_0123456789876543210Sym0 f0123456789876543210-      where-        Lambda_0123456789876543210Sym0KindInference :: forall f0123456789876543210-                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>-                                                       Lambda_0123456789876543210Sym0 f0123456789876543210-    type instance Apply Lambda_0123456789876543210Sym0 f0123456789876543210 = Lambda_0123456789876543210Sym1 f0123456789876543210-    type family TFHelper_0123456789876543210 (a :: (~>) a b) (a :: (~>) a b) :: (~>) a b where-      TFHelper_0123456789876543210 f g = Apply (Apply Lambda_0123456789876543210Sym0 f) g-    type TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) =-        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())-    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)-      where-        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                a0123456789876543210-                                                                arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())-    data TFHelper_0123456789876543210Sym0 :: forall a0123456789876543210-                                                    b0123456789876543210.-                                             (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210))-      where-        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>-                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210-    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210-    instance PS ((~>) a b) where-      type (<<>>) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a-    class SS a where-      (%<<>>) ::-        forall (t :: a) (t :: a).-        Sing t -> Sing t -> Sing (Apply (Apply (<<>>@#@$) t) t :: a)-    instance SS b => SS ((~>) a b) where-      (%<<>>) ::-        forall (t :: (~>) a b) (t :: (~>) a b).-        Sing t -> Sing t -> Sing (Apply (Apply (<<>>@#@$) t) t :: (~>) a b)-      (%<<>>) (sF :: Sing f) (sG :: Sing g)-        = (singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 f) g))-            (\ sX-               -> case sX of {-                    (_ :: Sing x)-                      -> (applySing-                            ((applySing ((singFun2 @(<<>>@#@$)) (%<<>>))) ((applySing sF) sX)))-                           ((applySing sG) sX) })-    instance SS a => SingI ((<<>>@#@$) :: (~>) a ((~>) a a)) where-      sing = (singFun2 @(<<>>@#@$)) (%<<>>)-    instance (SS a, SingI d) =>-             SingI ((<<>>@#@$$) (d :: a) :: (~>) a a) where-      sing = (singFun1 @((<<>>@#@$$) (d :: a))) ((%<<>>) (sing @d))
+ tests/compile-and-dump/Singletons/T287.ghc88.template view
@@ -0,0 +1,116 @@+Singletons/T287.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| class S a where+            (<<>>) :: a -> a -> a+          +          instance S b => S (a -> b) where+            f <<>> g = \ x -> f x <<>> g x |]+  ======>+    class S a where+      (<<>>) :: a -> a -> a+    instance S b => S (a -> b) where+      (<<>>) f g = \ x -> (f x <<>> g x)+    type (<<>>@#@$$$) (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: a0123456789876543210) =+        (<<>>) arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings ((<<>>@#@$$) arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:<<>>@#@$$###)) ())+    data (<<>>@#@$$) (arg0123456789876543210 :: a0123456789876543210) :: (~>) a0123456789876543210 a0123456789876543210+      where+        (:<<>>@#@$$###) :: forall arg0123456789876543210+                                  arg0123456789876543210+                                  arg. SameKind (Apply ((<<>>@#@$$) arg0123456789876543210) arg) ((<<>>@#@$$$) arg0123456789876543210 arg) =>+                           (<<>>@#@$$) arg0123456789876543210 arg0123456789876543210+    type instance Apply ((<<>>@#@$$) arg0123456789876543210) arg0123456789876543210 = (<<>>) arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (<<>>@#@$) where+      suppressUnusedWarnings = snd (((,) (:<<>>@#@$###)) ())+    data (<<>>@#@$) :: forall a0123456789876543210.+                       (~>) a0123456789876543210 ((~>) a0123456789876543210 a0123456789876543210)+      where+        (:<<>>@#@$###) :: forall arg0123456789876543210+                                 arg. SameKind (Apply (<<>>@#@$) arg) ((<<>>@#@$$) arg) =>+                          (<<>>@#@$) arg0123456789876543210+    type instance Apply (<<>>@#@$) arg0123456789876543210 = (<<>>@#@$$) arg0123456789876543210+    class PS (a :: GHC.Types.Type) where+      type (<<>>) (arg :: a) (arg :: a) :: a+    type family Lambda_0123456789876543210 f g t where+      Lambda_0123456789876543210 f g x = Apply (Apply (<<>>@#@$) (Apply f x)) (Apply g x)+    type Lambda_0123456789876543210Sym3 f0123456789876543210 g0123456789876543210 t0123456789876543210 =+        Lambda_0123456789876543210 f0123456789876543210 g0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym2 g0123456789876543210 f0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym2KindInference) ())+    data Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210 t0123456789876543210+      where+        Lambda_0123456789876543210Sym2KindInference :: forall f0123456789876543210+                                                              g0123456789876543210+                                                              t0123456789876543210+                                                              arg. SameKind (Apply (Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210) arg) (Lambda_0123456789876543210Sym3 f0123456789876543210 g0123456789876543210 arg) =>+                                                       Lambda_0123456789876543210Sym2 f0123456789876543210 g0123456789876543210 t0123456789876543210+    type instance Apply (Lambda_0123456789876543210Sym2 g0123456789876543210 f0123456789876543210) t0123456789876543210 = Lambda_0123456789876543210 g0123456789876543210 f0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (Lambda_0123456789876543210Sym1 f0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym1KindInference) ())+    data Lambda_0123456789876543210Sym1 f0123456789876543210 g0123456789876543210+      where+        Lambda_0123456789876543210Sym1KindInference :: forall f0123456789876543210+                                                              g0123456789876543210+                                                              arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Lambda_0123456789876543210Sym0KindInference) ())+    data Lambda_0123456789876543210Sym0 f0123456789876543210+      where+        Lambda_0123456789876543210Sym0KindInference :: forall f0123456789876543210+                                                              arg. SameKind (Apply Lambda_0123456789876543210Sym0 arg) (Lambda_0123456789876543210Sym1 arg) =>+                                                       Lambda_0123456789876543210Sym0 f0123456789876543210+    type instance Apply Lambda_0123456789876543210Sym0 f0123456789876543210 = Lambda_0123456789876543210Sym1 f0123456789876543210+    type family TFHelper_0123456789876543210 (a :: (~>) a b) (a :: (~>) a b) :: (~>) a b where+      TFHelper_0123456789876543210 f g = Apply (Apply Lambda_0123456789876543210Sym0 f) g+    type TFHelper_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) =+        TFHelper_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (TFHelper_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym1KindInference) ())+    data TFHelper_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210)+      where+        TFHelper_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                a0123456789876543210+                                                                arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) TFHelper_0123456789876543210Sym0KindInference) ())+    data TFHelper_0123456789876543210Sym0 :: forall a0123456789876543210+                                                    b0123456789876543210.+                                             (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) a0123456789876543210 b0123456789876543210))+      where+        TFHelper_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply TFHelper_0123456789876543210Sym0 arg) (TFHelper_0123456789876543210Sym1 arg) =>+                                                         TFHelper_0123456789876543210Sym0 a0123456789876543210+    type instance Apply TFHelper_0123456789876543210Sym0 a0123456789876543210 = TFHelper_0123456789876543210Sym1 a0123456789876543210+    instance PS ((~>) a b) where+      type (<<>>) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a+    class SS a where+      (%<<>>) ::+        forall (t :: a) (t :: a).+        Sing t -> Sing t -> Sing (Apply (Apply (<<>>@#@$) t) t :: a)+    instance SS b => SS ((~>) a b) where+      (%<<>>) ::+        forall (t :: (~>) a b) (t :: (~>) a b).+        Sing t -> Sing t -> Sing (Apply (Apply (<<>>@#@$) t) t :: (~>) a b)+      (%<<>>) (sF :: Sing f) (sG :: Sing g)+        = (singFun1 @(Apply (Apply Lambda_0123456789876543210Sym0 f) g))+            (\ sX+               -> case sX of {+                    (_ :: Sing x)+                      -> (applySing+                            ((applySing ((singFun2 @(<<>>@#@$)) (%<<>>))) ((applySing sF) sX)))+                           ((applySing sG) sX) })+    instance SS a => SingI ((<<>>@#@$) :: (~>) a ((~>) a a)) where+      sing = (singFun2 @(<<>>@#@$)) (%<<>>)+    instance (SS a, SingI d) =>+             SingI ((<<>>@#@$$) (d :: a) :: (~>) a a) where+      sing = (singFun1 @((<<>>@#@$$) (d :: a))) ((%<<>>) (sing @d))
− tests/compile-and-dump/Singletons/T29.ghc86.template 
@@ -1,115 +0,0 @@-Singletons/T29.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo :: Bool -> Bool-          foo x = not $ x-          bar :: Bool -> Bool-          bar x = not . not . not $ x-          baz :: Bool -> Bool-          baz x = not $! x-          ban :: Bool -> Bool-          ban x = not . not . not $! x |]-  ======>-    foo :: Bool -> Bool-    foo x = (not $ x)-    bar :: Bool -> Bool-    bar x = ((not . (not . not)) $ x)-    baz :: Bool -> Bool-    baz x = (not $! x)-    ban :: Bool -> Bool-    ban x = ((not . (not . not)) $! x)-    type BanSym1 (a0123456789876543210 :: Bool) =-        Ban a0123456789876543210-    instance SuppressUnusedWarnings BanSym0 where-      suppressUnusedWarnings = snd (((,) BanSym0KindInference) ())-    data BanSym0 :: (~>) Bool Bool-      where-        BanSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply BanSym0 arg) (BanSym1 arg) =>-                                BanSym0 a0123456789876543210-    type instance Apply BanSym0 a0123456789876543210 = Ban a0123456789876543210-    type BazSym1 (a0123456789876543210 :: Bool) =-        Baz a0123456789876543210-    instance SuppressUnusedWarnings BazSym0 where-      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())-    data BazSym0 :: (~>) Bool Bool-      where-        BazSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply BazSym0 arg) (BazSym1 arg) =>-                                BazSym0 a0123456789876543210-    type instance Apply BazSym0 a0123456789876543210 = Baz a0123456789876543210-    type BarSym1 (a0123456789876543210 :: Bool) =-        Bar a0123456789876543210-    instance SuppressUnusedWarnings BarSym0 where-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())-    data BarSym0 :: (~>) Bool Bool-      where-        BarSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>-                                BarSym0 a0123456789876543210-    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210-    type FooSym1 (a0123456789876543210 :: Bool) =-        Foo a0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: (~>) Bool Bool-      where-        FooSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210-    type family Ban (a :: Bool) :: Bool where-      Ban x = Apply (Apply ($!@#@$) (Apply (Apply (.@#@$) NotSym0) (Apply (Apply (.@#@$) NotSym0) NotSym0))) x-    type family Baz (a :: Bool) :: Bool where-      Baz x = Apply (Apply ($!@#@$) NotSym0) x-    type family Bar (a :: Bool) :: Bool where-      Bar x = Apply (Apply ($@#@$) (Apply (Apply (.@#@$) NotSym0) (Apply (Apply (.@#@$) NotSym0) NotSym0))) x-    type family Foo (a :: Bool) :: Bool where-      Foo x = Apply (Apply ($@#@$) NotSym0) x-    sBan ::-      forall (t :: Bool). Sing t -> Sing (Apply BanSym0 t :: Bool)-    sBaz ::-      forall (t :: Bool). Sing t -> Sing (Apply BazSym0 t :: Bool)-    sBar ::-      forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool)-    sFoo ::-      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)-    sBan (sX :: Sing x)-      = (applySing-           ((applySing ((singFun2 @($!@#@$)) (%$!)))-              ((applySing-                  ((applySing ((singFun3 @(.@#@$)) (%.)))-                     ((singFun1 @NotSym0) sNot)))-                 ((applySing-                     ((applySing ((singFun3 @(.@#@$)) (%.)))-                        ((singFun1 @NotSym0) sNot)))-                    ((singFun1 @NotSym0) sNot)))))-          sX-    sBaz (sX :: Sing x)-      = (applySing-           ((applySing ((singFun2 @($!@#@$)) (%$!)))-              ((singFun1 @NotSym0) sNot)))-          sX-    sBar (sX :: Sing x)-      = (applySing-           ((applySing ((singFun2 @($@#@$)) (%$)))-              ((applySing-                  ((applySing ((singFun3 @(.@#@$)) (%.)))-                     ((singFun1 @NotSym0) sNot)))-                 ((applySing-                     ((applySing ((singFun3 @(.@#@$)) (%.)))-                        ((singFun1 @NotSym0) sNot)))-                    ((singFun1 @NotSym0) sNot)))))-          sX-    sFoo (sX :: Sing x)-      = (applySing-           ((applySing ((singFun2 @($@#@$)) (%$)))-              ((singFun1 @NotSym0) sNot)))-          sX-    instance SingI (BanSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @BanSym0) sBan-    instance SingI (BazSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @BazSym0) sBaz-    instance SingI (BarSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @BarSym0) sBar-    instance SingI (FooSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @FooSym0) sFoo
+ tests/compile-and-dump/Singletons/T29.ghc88.template view
@@ -0,0 +1,115 @@+Singletons/T29.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo :: Bool -> Bool+          foo x = not $ x+          bar :: Bool -> Bool+          bar x = not . not . not $ x+          baz :: Bool -> Bool+          baz x = not $! x+          ban :: Bool -> Bool+          ban x = not . not . not $! x |]+  ======>+    foo :: Bool -> Bool+    foo x = (not $ x)+    bar :: Bool -> Bool+    bar x = ((not . (not . not)) $ x)+    baz :: Bool -> Bool+    baz x = (not $! x)+    ban :: Bool -> Bool+    ban x = ((not . (not . not)) $! x)+    type BanSym1 (a0123456789876543210 :: Bool) =+        Ban a0123456789876543210+    instance SuppressUnusedWarnings BanSym0 where+      suppressUnusedWarnings = snd (((,) BanSym0KindInference) ())+    data BanSym0 :: (~>) Bool Bool+      where+        BanSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply BanSym0 arg) (BanSym1 arg) =>+                                BanSym0 a0123456789876543210+    type instance Apply BanSym0 a0123456789876543210 = Ban a0123456789876543210+    type BazSym1 (a0123456789876543210 :: Bool) =+        Baz a0123456789876543210+    instance SuppressUnusedWarnings BazSym0 where+      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())+    data BazSym0 :: (~>) Bool Bool+      where+        BazSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply BazSym0 arg) (BazSym1 arg) =>+                                BazSym0 a0123456789876543210+    type instance Apply BazSym0 a0123456789876543210 = Baz a0123456789876543210+    type BarSym1 (a0123456789876543210 :: Bool) =+        Bar a0123456789876543210+    instance SuppressUnusedWarnings BarSym0 where+      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())+    data BarSym0 :: (~>) Bool Bool+      where+        BarSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>+                                BarSym0 a0123456789876543210+    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210+    type FooSym1 (a0123456789876543210 :: Bool) =+        Foo a0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: (~>) Bool Bool+      where+        FooSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 a0123456789876543210+    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210+    type family Ban (a :: Bool) :: Bool where+      Ban x = Apply (Apply ($!@#@$) (Apply (Apply (.@#@$) NotSym0) (Apply (Apply (.@#@$) NotSym0) NotSym0))) x+    type family Baz (a :: Bool) :: Bool where+      Baz x = Apply (Apply ($!@#@$) NotSym0) x+    type family Bar (a :: Bool) :: Bool where+      Bar x = Apply (Apply ($@#@$) (Apply (Apply (.@#@$) NotSym0) (Apply (Apply (.@#@$) NotSym0) NotSym0))) x+    type family Foo (a :: Bool) :: Bool where+      Foo x = Apply (Apply ($@#@$) NotSym0) x+    sBan ::+      forall (t :: Bool). Sing t -> Sing (Apply BanSym0 t :: Bool)+    sBaz ::+      forall (t :: Bool). Sing t -> Sing (Apply BazSym0 t :: Bool)+    sBar ::+      forall (t :: Bool). Sing t -> Sing (Apply BarSym0 t :: Bool)+    sFoo ::+      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)+    sBan (sX :: Sing x)+      = (applySing+           ((applySing ((singFun2 @($!@#@$)) (%$!)))+              ((applySing+                  ((applySing ((singFun3 @(.@#@$)) (%.)))+                     ((singFun1 @NotSym0) sNot)))+                 ((applySing+                     ((applySing ((singFun3 @(.@#@$)) (%.)))+                        ((singFun1 @NotSym0) sNot)))+                    ((singFun1 @NotSym0) sNot)))))+          sX+    sBaz (sX :: Sing x)+      = (applySing+           ((applySing ((singFun2 @($!@#@$)) (%$!)))+              ((singFun1 @NotSym0) sNot)))+          sX+    sBar (sX :: Sing x)+      = (applySing+           ((applySing ((singFun2 @($@#@$)) (%$)))+              ((applySing+                  ((applySing ((singFun3 @(.@#@$)) (%.)))+                     ((singFun1 @NotSym0) sNot)))+                 ((applySing+                     ((applySing ((singFun3 @(.@#@$)) (%.)))+                        ((singFun1 @NotSym0) sNot)))+                    ((singFun1 @NotSym0) sNot)))))+          sX+    sFoo (sX :: Sing x)+      = (applySing+           ((applySing ((singFun2 @($@#@$)) (%$)))+              ((singFun1 @NotSym0) sNot)))+          sX+    instance SingI (BanSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @BanSym0) sBan+    instance SingI (BazSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @BazSym0) sBaz+    instance SingI (BarSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @BarSym0) sBar+    instance SingI (FooSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @FooSym0) sFoo
− tests/compile-and-dump/Singletons/T297.ghc86.template 
@@ -1,59 +0,0 @@-Singletons/T297.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| f MyProxy-            = let-                x = let-                      z :: MyProxy a-                      z = MyProxy-                    in z-              in x-          -          data MyProxy (a :: Type) = MyProxy |]-  ======>-    data MyProxy (a :: Type) = MyProxy-    f MyProxy-      = let-          x = let-                z :: MyProxy a-                z = MyProxy-              in z-        in x-    type MyProxySym0 = MyProxy-    type Let0123456789876543210ZSym0 = Let0123456789876543210Z-    type family Let0123456789876543210Z :: MyProxy a where-      Let0123456789876543210Z = MyProxySym0-    type Let0123456789876543210XSym0 = Let0123456789876543210X-    type family Let0123456789876543210X where-      Let0123456789876543210X = Let0123456789876543210ZSym0-    type FSym1 a0123456789876543210 = F a0123456789876543210-    instance SuppressUnusedWarnings FSym0 where-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())-    data FSym0 a0123456789876543210-      where-        FSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>-                              FSym0 a0123456789876543210-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210-    type family F a where-      F MyProxy = Let0123456789876543210XSym0-    sF :: forall arg. Sing arg -> Sing (Apply FSym0 arg)-    sF SMyProxy-      = let-          sX :: Sing Let0123456789876543210XSym0-          sX-            = let-                sZ :: forall a. Sing (Let0123456789876543210ZSym0 :: MyProxy a)-                sZ = SMyProxy-              in sZ-        in sX-    instance SingI FSym0 where-      sing = (singFun1 @FSym0) sF-    data instance Sing :: MyProxy a -> Type-      where SMyProxy :: Sing MyProxy-    type SMyProxy = (Sing :: MyProxy a -> Type)-    instance SingKind a => SingKind (MyProxy a) where-      type Demote (MyProxy a) = MyProxy (Demote a)-      fromSing SMyProxy = MyProxy-      toSing MyProxy = SomeSing SMyProxy-    instance SingI MyProxy where-      sing = SMyProxy
+ tests/compile-and-dump/Singletons/T297.ghc88.template view
@@ -0,0 +1,59 @@+Singletons/T297.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| f MyProxy+            = let+                x = let+                      z :: MyProxy a+                      z = MyProxy+                    in z+              in x+          +          data MyProxy (a :: Type) = MyProxy |]+  ======>+    data MyProxy (a :: Type) = MyProxy+    f MyProxy+      = let+          x = let+                z :: MyProxy a+                z = MyProxy+              in z+        in x+    type MyProxySym0 = MyProxy+    type Let0123456789876543210ZSym0 = Let0123456789876543210Z+    type family Let0123456789876543210Z :: MyProxy a where+      Let0123456789876543210Z = MyProxySym0+    type Let0123456789876543210XSym0 = Let0123456789876543210X+    type family Let0123456789876543210X where+      Let0123456789876543210X = Let0123456789876543210ZSym0+    type FSym1 a0123456789876543210 = F a0123456789876543210+    instance SuppressUnusedWarnings FSym0 where+      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())+    data FSym0 a0123456789876543210+      where+        FSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>+                              FSym0 a0123456789876543210+    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210+    type family F a where+      F MyProxy = Let0123456789876543210XSym0+    sF :: forall arg. Sing arg -> Sing (Apply FSym0 arg)+    sF SMyProxy+      = let+          sX :: Sing Let0123456789876543210XSym0+          sX+            = let+                sZ :: forall a. Sing (Let0123456789876543210ZSym0 :: MyProxy a)+                sZ = SMyProxy+              in sZ+        in sX+    instance SingI FSym0 where+      sing = (singFun1 @FSym0) sF+    data SMyProxy :: forall a. MyProxy a -> Type+      where SMyProxy :: SMyProxy MyProxy+    type instance Sing @(MyProxy a) = SMyProxy+    instance SingKind a => SingKind (MyProxy a) where+      type Demote (MyProxy a) = MyProxy (Demote a)+      fromSing SMyProxy = MyProxy+      toSing MyProxy = SomeSing SMyProxy+    instance SingI MyProxy where+      sing = SMyProxy
− tests/compile-and-dump/Singletons/T312.ghc86.template 
@@ -1,215 +0,0 @@-Singletons/T312.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| class Foo a where-            bar :: a -> b -> b-            bar _ x = x-            baz :: forall b. a -> b -> b-            baz-              = h-              where-                  h :: forall c. c -> b -> b-                  h _ x = x |]-  ======>-    class Foo a where-      bar :: a -> b -> b-      baz :: forall b. a -> b -> b-      bar _ x = x-      baz-        = h-        where-            h :: forall c. c -> b -> b-            h _ x = x-    type BarSym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: b0123456789876543210) =-        Bar arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (BarSym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BarSym1KindInference) ())-    data BarSym1 (arg0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                     (~>) b0123456789876543210 b0123456789876543210-      where-        BarSym1KindInference :: forall arg0123456789876543210-                                       arg0123456789876543210-                                       arg. SameKind (Apply (BarSym1 arg0123456789876543210) arg) (BarSym2 arg0123456789876543210 arg) =>-                                BarSym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (BarSym1 arg0123456789876543210) arg0123456789876543210 = Bar arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings BarSym0 where-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())-    data BarSym0 :: forall a0123456789876543210 b0123456789876543210.-                    (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)-      where-        BarSym0KindInference :: forall arg0123456789876543210-                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>-                                BarSym0 arg0123456789876543210-    type instance Apply BarSym0 arg0123456789876543210 = BarSym1 arg0123456789876543210-    type BazSym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: b0123456789876543210) =-        Baz arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings (BazSym1 arg0123456789876543210) where-      suppressUnusedWarnings = snd (((,) BazSym1KindInference) ())-    data BazSym1 (arg0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                     (~>) b0123456789876543210 b0123456789876543210-      where-        BazSym1KindInference :: forall arg0123456789876543210-                                       arg0123456789876543210-                                       arg. SameKind (Apply (BazSym1 arg0123456789876543210) arg) (BazSym2 arg0123456789876543210 arg) =>-                                BazSym1 arg0123456789876543210 arg0123456789876543210-    type instance Apply (BazSym1 arg0123456789876543210) arg0123456789876543210 = Baz arg0123456789876543210 arg0123456789876543210-    instance SuppressUnusedWarnings BazSym0 where-      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())-    data BazSym0 :: forall a0123456789876543210 b0123456789876543210.-                    (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)-      where-        BazSym0KindInference :: forall arg0123456789876543210-                                       arg. SameKind (Apply BazSym0 arg) (BazSym1 arg) =>-                                BazSym0 arg0123456789876543210-    type instance Apply BazSym0 arg0123456789876543210 = BazSym1 arg0123456789876543210-    type family Bar_0123456789876543210 (a :: a) (a :: b) :: b where-      Bar_0123456789876543210 _ x = x-    type Bar_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Bar_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Bar_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Bar_0123456789876543210Sym1KindInference) ())-    data Bar_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                                       (~>) b0123456789876543210 b0123456789876543210-      where-        Bar_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                           a0123456789876543210-                                                           arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Bar_0123456789876543210Sym0KindInference) ())-    data Bar_0123456789876543210Sym0 :: forall a0123456789876543210-                                               b0123456789876543210.-                                        (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)-      where-        Bar_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                           arg. SameKind (Apply Bar_0123456789876543210Sym0 arg) (Bar_0123456789876543210Sym1 arg) =>-                                                    Bar_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Bar_0123456789876543210Sym0 a0123456789876543210 = Bar_0123456789876543210Sym1 a0123456789876543210-    type Let0123456789876543210HSym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 (a0123456789876543210 :: c0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Let0123456789876543210H a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210HSym3 a0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210HSym3KindInference) ())-    data Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 (a0123456789876543210 :: c0123456789876543210) :: forall b0123456789876543210.-                                                                                                                                                                         (~>) b0123456789876543210 b0123456789876543210-      where-        Let0123456789876543210HSym3KindInference :: forall a_01234567898765432100123456789876543210-                                                           a_01234567898765432100123456789876543210-                                                           a0123456789876543210-                                                           a0123456789876543210-                                                           arg. 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 a0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a0123456789876543210 = Let0123456789876543210H a0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210HSym2KindInference) ())-    data Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 :: forall b0123456789876543210-                                                                                                                                 c0123456789876543210.-                                                                                                                          (~>) c0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)-      where-        Let0123456789876543210HSym2KindInference :: forall a_01234567898765432100123456789876543210-                                                           a_01234567898765432100123456789876543210-                                                           a0123456789876543210-                                                           arg. 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 (Let0123456789876543210HSym1 a_01234567898765432100123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210HSym1KindInference) ())-    data Let0123456789876543210HSym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210-      where-        Let0123456789876543210HSym1KindInference :: forall a_01234567898765432100123456789876543210-                                                           a_01234567898765432100123456789876543210-                                                           arg. 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 Let0123456789876543210HSym0 where-      suppressUnusedWarnings-        = snd (((,) Let0123456789876543210HSym0KindInference) ())-    data Let0123456789876543210HSym0 a_01234567898765432100123456789876543210-      where-        Let0123456789876543210HSym0KindInference :: forall a_01234567898765432100123456789876543210-                                                           arg. SameKind (Apply Let0123456789876543210HSym0 arg) (Let0123456789876543210HSym1 arg) =>-                                                    Let0123456789876543210HSym0 a_01234567898765432100123456789876543210-    type instance Apply Let0123456789876543210HSym0 a_01234567898765432100123456789876543210 = Let0123456789876543210HSym1 a_01234567898765432100123456789876543210-    type family Let0123456789876543210H a_0123456789876543210 a_0123456789876543210 (a :: c) (a :: b) :: b where-      Let0123456789876543210H a_0123456789876543210 a_0123456789876543210 _ x = x-    type family Baz_0123456789876543210 (a :: a) (a :: b) :: b where-      Baz_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210-    type Baz_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =-        Baz_0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (Baz_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) Baz_0123456789876543210Sym1KindInference) ())-    data Baz_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.-                                                                                       (~>) b0123456789876543210 b0123456789876543210-      where-        Baz_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                           a0123456789876543210-                                                           arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Baz_0123456789876543210Sym0KindInference) ())-    data Baz_0123456789876543210Sym0 :: forall a0123456789876543210-                                               b0123456789876543210.-                                        (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)-      where-        Baz_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                           arg. SameKind (Apply Baz_0123456789876543210Sym0 arg) (Baz_0123456789876543210Sym1 arg) =>-                                                    Baz_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Baz_0123456789876543210Sym0 a0123456789876543210 = Baz_0123456789876543210Sym1 a0123456789876543210-    class PFoo (a :: GHC.Types.Type) where-      type Bar (arg :: a) (arg :: b) :: b-      type 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-    class SFoo a where-      sBar ::-        forall b (t :: a) (t :: b).-        Sing t -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b)-      sBaz ::-        forall b (t :: a) (t :: b).-        Sing t -> Sing t -> Sing (Apply (Apply BazSym0 t) t :: b)-      default sBar ::-                forall b (t :: a) (t :: b).-                (Apply (Apply BarSym0 t) t :: b)-                ~ Apply (Apply Bar_0123456789876543210Sym0 t) t =>-                Sing t -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b)-      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)-      sBar _ (sX :: Sing x) = sX-      sBaz-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 (let-                    sH ::-                      forall c (t :: c) (t :: b).-                      Sing t-                      -> Sing t-                         -> Sing (Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) t) t :: b)-                    sH _ (sX :: Sing x) = sX-                  in-                    (singFun2-                       @(Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210))-                      sH))-                sA_0123456789876543210))-            sA_0123456789876543210-    instance SFoo a => SingI (BarSym0 :: (~>) a ((~>) b b)) where-      sing = (singFun2 @BarSym0) sBar-    instance (SFoo a, SingI d) =>-             SingI (BarSym1 (d :: a) :: (~>) b b) where-      sing = (singFun1 @(BarSym1 (d :: a))) (sBar (sing @d))-    instance SFoo a => SingI (BazSym0 :: (~>) a ((~>) b b)) where-      sing = (singFun2 @BazSym0) sBaz-    instance (SFoo a, SingI d) =>-             SingI (BazSym1 (d :: a) :: (~>) b b) where-      sing = (singFun1 @(BazSym1 (d :: a))) (sBaz (sing @d))
+ tests/compile-and-dump/Singletons/T312.ghc88.template view
@@ -0,0 +1,215 @@+Singletons/T312.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| class Foo a where+            bar :: a -> b -> b+            bar _ x = x+            baz :: forall b. a -> b -> b+            baz+              = h+              where+                  h :: forall c. c -> b -> b+                  h _ x = x |]+  ======>+    class Foo a where+      bar :: a -> b -> b+      baz :: forall b. a -> b -> b+      bar _ x = x+      baz+        = h+        where+            h :: forall c. c -> b -> b+            h _ x = x+    type BarSym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: b0123456789876543210) =+        Bar arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (BarSym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BarSym1KindInference) ())+    data BarSym1 (arg0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                     (~>) b0123456789876543210 b0123456789876543210+      where+        BarSym1KindInference :: forall arg0123456789876543210+                                       arg0123456789876543210+                                       arg. SameKind (Apply (BarSym1 arg0123456789876543210) arg) (BarSym2 arg0123456789876543210 arg) =>+                                BarSym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (BarSym1 arg0123456789876543210) arg0123456789876543210 = Bar arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings BarSym0 where+      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())+    data BarSym0 :: forall a0123456789876543210 b0123456789876543210.+                    (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)+      where+        BarSym0KindInference :: forall arg0123456789876543210+                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>+                                BarSym0 arg0123456789876543210+    type instance Apply BarSym0 arg0123456789876543210 = BarSym1 arg0123456789876543210+    type BazSym2 (arg0123456789876543210 :: a0123456789876543210) (arg0123456789876543210 :: b0123456789876543210) =+        Baz arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings (BazSym1 arg0123456789876543210) where+      suppressUnusedWarnings = snd (((,) BazSym1KindInference) ())+    data BazSym1 (arg0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                     (~>) b0123456789876543210 b0123456789876543210+      where+        BazSym1KindInference :: forall arg0123456789876543210+                                       arg0123456789876543210+                                       arg. SameKind (Apply (BazSym1 arg0123456789876543210) arg) (BazSym2 arg0123456789876543210 arg) =>+                                BazSym1 arg0123456789876543210 arg0123456789876543210+    type instance Apply (BazSym1 arg0123456789876543210) arg0123456789876543210 = Baz arg0123456789876543210 arg0123456789876543210+    instance SuppressUnusedWarnings BazSym0 where+      suppressUnusedWarnings = snd (((,) BazSym0KindInference) ())+    data BazSym0 :: forall a0123456789876543210 b0123456789876543210.+                    (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)+      where+        BazSym0KindInference :: forall arg0123456789876543210+                                       arg. SameKind (Apply BazSym0 arg) (BazSym1 arg) =>+                                BazSym0 arg0123456789876543210+    type instance Apply BazSym0 arg0123456789876543210 = BazSym1 arg0123456789876543210+    type family Bar_0123456789876543210 (a :: a) (a :: b) :: b where+      Bar_0123456789876543210 _ x = x+    type Bar_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Bar_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Bar_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Bar_0123456789876543210Sym1KindInference) ())+    data Bar_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                                       (~>) b0123456789876543210 b0123456789876543210+      where+        Bar_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                           a0123456789876543210+                                                           arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Bar_0123456789876543210Sym0KindInference) ())+    data Bar_0123456789876543210Sym0 :: forall a0123456789876543210+                                               b0123456789876543210.+                                        (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)+      where+        Bar_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                           arg. SameKind (Apply Bar_0123456789876543210Sym0 arg) (Bar_0123456789876543210Sym1 arg) =>+                                                    Bar_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Bar_0123456789876543210Sym0 a0123456789876543210 = Bar_0123456789876543210Sym1 a0123456789876543210+    type Let0123456789876543210HSym4 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 (a0123456789876543210 :: c0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Let0123456789876543210H a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210HSym3 a0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210HSym3KindInference) ())+    data Let0123456789876543210HSym3 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 (a0123456789876543210 :: c0123456789876543210) :: forall b0123456789876543210.+                                                                                                                                                                         (~>) b0123456789876543210 b0123456789876543210+      where+        Let0123456789876543210HSym3KindInference :: forall a_01234567898765432100123456789876543210+                                                           a_01234567898765432100123456789876543210+                                                           a0123456789876543210+                                                           a0123456789876543210+                                                           arg. 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 a0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) a0123456789876543210 = Let0123456789876543210H a0123456789876543210 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210HSym2KindInference) ())+    data Let0123456789876543210HSym2 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 :: forall c0123456789876543210+                                                                                                                                 b0123456789876543210.+                                                                                                                          (~>) c0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)+      where+        Let0123456789876543210HSym2KindInference :: forall a_01234567898765432100123456789876543210+                                                           a_01234567898765432100123456789876543210+                                                           a0123456789876543210+                                                           arg. 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 (Let0123456789876543210HSym1 a_01234567898765432100123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210HSym1KindInference) ())+    data Let0123456789876543210HSym1 a_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210+      where+        Let0123456789876543210HSym1KindInference :: forall a_01234567898765432100123456789876543210+                                                           a_01234567898765432100123456789876543210+                                                           arg. 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 Let0123456789876543210HSym0 where+      suppressUnusedWarnings+        = snd (((,) Let0123456789876543210HSym0KindInference) ())+    data Let0123456789876543210HSym0 a_01234567898765432100123456789876543210+      where+        Let0123456789876543210HSym0KindInference :: forall a_01234567898765432100123456789876543210+                                                           arg. SameKind (Apply Let0123456789876543210HSym0 arg) (Let0123456789876543210HSym1 arg) =>+                                                    Let0123456789876543210HSym0 a_01234567898765432100123456789876543210+    type instance Apply Let0123456789876543210HSym0 a_01234567898765432100123456789876543210 = Let0123456789876543210HSym1 a_01234567898765432100123456789876543210+    type family Let0123456789876543210H a_0123456789876543210 a_0123456789876543210 (a :: c) (a :: b) :: b where+      Let0123456789876543210H a_0123456789876543210 a_0123456789876543210 _ x = x+    type family Baz_0123456789876543210 (a :: a) (a :: b) :: b where+      Baz_0123456789876543210 a_0123456789876543210 a_0123456789876543210 = Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) a_0123456789876543210) a_0123456789876543210+    type Baz_0123456789876543210Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Baz_0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (Baz_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) Baz_0123456789876543210Sym1KindInference) ())+    data Baz_0123456789876543210Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                                       (~>) b0123456789876543210 b0123456789876543210+      where+        Baz_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                           a0123456789876543210+                                                           arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Baz_0123456789876543210Sym0KindInference) ())+    data Baz_0123456789876543210Sym0 :: forall a0123456789876543210+                                               b0123456789876543210.+                                        (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)+      where+        Baz_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                           arg. SameKind (Apply Baz_0123456789876543210Sym0 arg) (Baz_0123456789876543210Sym1 arg) =>+                                                    Baz_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Baz_0123456789876543210Sym0 a0123456789876543210 = Baz_0123456789876543210Sym1 a0123456789876543210+    class PFoo (a :: GHC.Types.Type) where+      type Bar (arg :: a) (arg :: b) :: b+      type 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+    class SFoo a where+      sBar ::+        forall b (t :: a) (t :: b).+        Sing t -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b)+      sBaz ::+        forall b (t :: a) (t :: b).+        Sing t -> Sing t -> Sing (Apply (Apply BazSym0 t) t :: b)+      default sBar ::+                forall b (t :: a) (t :: b).+                ((Apply (Apply BarSym0 t) t :: b)+                 ~ Apply (Apply Bar_0123456789876543210Sym0 t) t) =>+                Sing t -> Sing t -> Sing (Apply (Apply BarSym0 t) t :: b)+      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)+      sBar _ (sX :: Sing x) = sX+      sBaz+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 (let+                    sH ::+                      forall c (t :: c) (t :: b).+                      Sing t+                      -> Sing t+                         -> Sing (Apply (Apply (Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210) t) t :: b)+                    sH _ (sX :: Sing x) = sX+                  in+                    (singFun2+                       @(Let0123456789876543210HSym2 a_0123456789876543210 a_0123456789876543210))+                      sH))+                sA_0123456789876543210))+            sA_0123456789876543210+    instance SFoo a => SingI (BarSym0 :: (~>) a ((~>) b b)) where+      sing = (singFun2 @BarSym0) sBar+    instance (SFoo a, SingI d) =>+             SingI (BarSym1 (d :: a) :: (~>) b b) where+      sing = (singFun1 @(BarSym1 (d :: a))) (sBar (sing @d))+    instance SFoo a => SingI (BazSym0 :: (~>) a ((~>) b b)) where+      sing = (singFun2 @BazSym0) sBaz+    instance (SFoo a, SingI d) =>+             SingI (BazSym1 (d :: a) :: (~>) b b) where+      sing = (singFun1 @(BazSym1 (d :: a))) (sBaz (sing @d))
− tests/compile-and-dump/Singletons/T313.ghc86.template 
@@ -1,130 +0,0 @@-Singletons/T313.hs:(0,0)-(0,0): Splicing declarations-    promote-      [d| type PFoo1 a = Maybe a-          type family PFoo2 a-          type family PFoo3 a where-            PFoo3 a = Maybe a-          class PC (a :: Type) where-            type PFoo4 a-            type PFoo4 a = Maybe a-          -          type instance PFoo2 a = Maybe a-          instance PC a where-            type PFoo4 a = Maybe a |]-  ======>-    type PFoo1 a = Maybe a-    type family PFoo2 a-    type instance PFoo2 a = Maybe a-    type family PFoo3 a where-      PFoo3 a = Maybe a-    class PC (a :: Type) where-      type PFoo4 a-      type PFoo4 a = Maybe a-    instance PC a where-      type PFoo4 a = Maybe a-    type PFoo1Sym1 a0123456789876543210 = PFoo1 a0123456789876543210-    instance SuppressUnusedWarnings PFoo1Sym0 where-      suppressUnusedWarnings = snd (((,) PFoo1Sym0KindInference) ())-    data PFoo1Sym0 a0123456789876543210-      where-        PFoo1Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply PFoo1Sym0 arg) (PFoo1Sym1 arg) =>-                                  PFoo1Sym0 a0123456789876543210-    type instance Apply PFoo1Sym0 a0123456789876543210 = PFoo1 a0123456789876543210-    type PFoo3Sym1 a0123456789876543210 = PFoo3 a0123456789876543210-    instance SuppressUnusedWarnings PFoo3Sym0 where-      suppressUnusedWarnings = snd (((,) PFoo3Sym0KindInference) ())-    data PFoo3Sym0 a0123456789876543210-      where-        PFoo3Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply PFoo3Sym0 arg) (PFoo3Sym1 arg) =>-                                  PFoo3Sym0 a0123456789876543210-    type instance Apply PFoo3Sym0 a0123456789876543210 = PFoo3 a0123456789876543210-    type PFoo2Sym1 (a0123456789876543210 :: Type) =-        PFoo2 a0123456789876543210-    instance SuppressUnusedWarnings PFoo2Sym0 where-      suppressUnusedWarnings = snd (((,) PFoo2Sym0KindInference) ())-    data PFoo2Sym0 :: (~>) Type Type-      where-        PFoo2Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply PFoo2Sym0 arg) (PFoo2Sym1 arg) =>-                                  PFoo2Sym0 a0123456789876543210-    type instance Apply PFoo2Sym0 a0123456789876543210 = PFoo2 a0123456789876543210-    type PFoo4Sym1 (a0123456789876543210 :: Type) =-        PFoo4 a0123456789876543210-    instance SuppressUnusedWarnings PFoo4Sym0 where-      suppressUnusedWarnings = snd (((,) PFoo4Sym0KindInference) ())-    data PFoo4Sym0 :: (~>) Type Type-      where-        PFoo4Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply PFoo4Sym0 arg) (PFoo4Sym1 arg) =>-                                  PFoo4Sym0 a0123456789876543210-    type instance Apply PFoo4Sym0 a0123456789876543210 = PFoo4 a0123456789876543210-    class PPC (a :: Type)-    instance PPC a-Singletons/T313.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| type SFoo1 a = Maybe a-          type family SFoo2 a-          type family SFoo3 a where-            SFoo3 a = Maybe a-          class SC (a :: Type) where-            type SFoo4 a-            type SFoo4 a = Maybe a-          -          type instance SFoo2 a = Maybe a-          instance SC a where-            type SFoo4 a = Maybe a |]-  ======>-    type SFoo1 a = Maybe a-    type family SFoo2 a-    type instance SFoo2 a = Maybe a-    type family SFoo3 a where-      SFoo3 a = Maybe a-    class SC (a :: Type) where-      type SFoo4 a-      type SFoo4 a = Maybe a-    instance SC a where-      type SFoo4 a = Maybe a-    type SFoo1Sym1 a0123456789876543210 = SFoo1 a0123456789876543210-    instance SuppressUnusedWarnings SFoo1Sym0 where-      suppressUnusedWarnings = snd (((,) SFoo1Sym0KindInference) ())-    data SFoo1Sym0 a0123456789876543210-      where-        SFoo1Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply SFoo1Sym0 arg) (SFoo1Sym1 arg) =>-                                  SFoo1Sym0 a0123456789876543210-    type instance Apply SFoo1Sym0 a0123456789876543210 = SFoo1 a0123456789876543210-    type SFoo3Sym1 a0123456789876543210 = SFoo3 a0123456789876543210-    instance SuppressUnusedWarnings SFoo3Sym0 where-      suppressUnusedWarnings = snd (((,) SFoo3Sym0KindInference) ())-    data SFoo3Sym0 a0123456789876543210-      where-        SFoo3Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply SFoo3Sym0 arg) (SFoo3Sym1 arg) =>-                                  SFoo3Sym0 a0123456789876543210-    type instance Apply SFoo3Sym0 a0123456789876543210 = SFoo3 a0123456789876543210-    type SFoo2Sym1 (a0123456789876543210 :: Type) =-        SFoo2 a0123456789876543210-    instance SuppressUnusedWarnings SFoo2Sym0 where-      suppressUnusedWarnings = snd (((,) SFoo2Sym0KindInference) ())-    data SFoo2Sym0 :: (~>) Type Type-      where-        SFoo2Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply SFoo2Sym0 arg) (SFoo2Sym1 arg) =>-                                  SFoo2Sym0 a0123456789876543210-    type instance Apply SFoo2Sym0 a0123456789876543210 = SFoo2 a0123456789876543210-    type SFoo4Sym1 (a0123456789876543210 :: Type) =-        SFoo4 a0123456789876543210-    instance SuppressUnusedWarnings SFoo4Sym0 where-      suppressUnusedWarnings = snd (((,) SFoo4Sym0KindInference) ())-    data SFoo4Sym0 :: (~>) Type Type-      where-        SFoo4Sym0KindInference :: forall a0123456789876543210-                                         arg. SameKind (Apply SFoo4Sym0 arg) (SFoo4Sym1 arg) =>-                                  SFoo4Sym0 a0123456789876543210-    type instance Apply SFoo4Sym0 a0123456789876543210 = SFoo4 a0123456789876543210-    class PSC (a :: Type)-    instance PSC a-    class SSC (a :: Type)-    instance SSC a
+ tests/compile-and-dump/Singletons/T313.ghc88.template view
@@ -0,0 +1,130 @@+Singletons/T313.hs:(0,0)-(0,0): Splicing declarations+    promote+      [d| type PFoo1 a = Maybe a+          type family PFoo2 a+          type family PFoo3 a where+            PFoo3 a = Maybe a+          class PC (a :: Type) where+            type PFoo4 a+            type PFoo4 a = Maybe a+          +          type instance PFoo2 a = Maybe a+          instance PC a where+            type PFoo4 a = Maybe a |]+  ======>+    type PFoo1 a = Maybe a+    type family PFoo2 a+    type instance PFoo2 a = Maybe a+    type family PFoo3 a where+      PFoo3 a = Maybe a+    class PC (a :: Type) where+      type PFoo4 a+      type PFoo4 a = Maybe a+    instance PC a where+      type PFoo4 a = Maybe a+    type PFoo1Sym1 a0123456789876543210 = PFoo1 a0123456789876543210+    instance SuppressUnusedWarnings PFoo1Sym0 where+      suppressUnusedWarnings = snd (((,) PFoo1Sym0KindInference) ())+    data PFoo1Sym0 a0123456789876543210+      where+        PFoo1Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply PFoo1Sym0 arg) (PFoo1Sym1 arg) =>+                                  PFoo1Sym0 a0123456789876543210+    type instance Apply PFoo1Sym0 a0123456789876543210 = PFoo1 a0123456789876543210+    type PFoo3Sym1 a0123456789876543210 = PFoo3 a0123456789876543210+    instance SuppressUnusedWarnings PFoo3Sym0 where+      suppressUnusedWarnings = snd (((,) PFoo3Sym0KindInference) ())+    data PFoo3Sym0 a0123456789876543210+      where+        PFoo3Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply PFoo3Sym0 arg) (PFoo3Sym1 arg) =>+                                  PFoo3Sym0 a0123456789876543210+    type instance Apply PFoo3Sym0 a0123456789876543210 = PFoo3 a0123456789876543210+    type PFoo2Sym1 (a0123456789876543210 :: Type) =+        PFoo2 a0123456789876543210+    instance SuppressUnusedWarnings PFoo2Sym0 where+      suppressUnusedWarnings = snd (((,) PFoo2Sym0KindInference) ())+    data PFoo2Sym0 :: (~>) Type Type+      where+        PFoo2Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply PFoo2Sym0 arg) (PFoo2Sym1 arg) =>+                                  PFoo2Sym0 a0123456789876543210+    type instance Apply PFoo2Sym0 a0123456789876543210 = PFoo2 a0123456789876543210+    type PFoo4Sym1 (a0123456789876543210 :: Type) =+        PFoo4 a0123456789876543210+    instance SuppressUnusedWarnings PFoo4Sym0 where+      suppressUnusedWarnings = snd (((,) PFoo4Sym0KindInference) ())+    data PFoo4Sym0 :: (~>) Type Type+      where+        PFoo4Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply PFoo4Sym0 arg) (PFoo4Sym1 arg) =>+                                  PFoo4Sym0 a0123456789876543210+    type instance Apply PFoo4Sym0 a0123456789876543210 = PFoo4 a0123456789876543210+    class PPC (a :: Type)+    instance PPC a+Singletons/T313.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| type SFoo1 a = Maybe a+          type family SFoo2 a+          type family SFoo3 a where+            SFoo3 a = Maybe a+          class SC (a :: Type) where+            type SFoo4 a+            type SFoo4 a = Maybe a+          +          type instance SFoo2 a = Maybe a+          instance SC a where+            type SFoo4 a = Maybe a |]+  ======>+    type SFoo1 a = Maybe a+    type family SFoo2 a+    type instance SFoo2 a = Maybe a+    type family SFoo3 a where+      SFoo3 a = Maybe a+    class SC (a :: Type) where+      type SFoo4 a+      type SFoo4 a = Maybe a+    instance SC a where+      type SFoo4 a = Maybe a+    type SFoo1Sym1 a0123456789876543210 = SFoo1 a0123456789876543210+    instance SuppressUnusedWarnings SFoo1Sym0 where+      suppressUnusedWarnings = snd (((,) SFoo1Sym0KindInference) ())+    data SFoo1Sym0 a0123456789876543210+      where+        SFoo1Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply SFoo1Sym0 arg) (SFoo1Sym1 arg) =>+                                  SFoo1Sym0 a0123456789876543210+    type instance Apply SFoo1Sym0 a0123456789876543210 = SFoo1 a0123456789876543210+    type SFoo3Sym1 a0123456789876543210 = SFoo3 a0123456789876543210+    instance SuppressUnusedWarnings SFoo3Sym0 where+      suppressUnusedWarnings = snd (((,) SFoo3Sym0KindInference) ())+    data SFoo3Sym0 a0123456789876543210+      where+        SFoo3Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply SFoo3Sym0 arg) (SFoo3Sym1 arg) =>+                                  SFoo3Sym0 a0123456789876543210+    type instance Apply SFoo3Sym0 a0123456789876543210 = SFoo3 a0123456789876543210+    type SFoo2Sym1 (a0123456789876543210 :: Type) =+        SFoo2 a0123456789876543210+    instance SuppressUnusedWarnings SFoo2Sym0 where+      suppressUnusedWarnings = snd (((,) SFoo2Sym0KindInference) ())+    data SFoo2Sym0 :: (~>) Type Type+      where+        SFoo2Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply SFoo2Sym0 arg) (SFoo2Sym1 arg) =>+                                  SFoo2Sym0 a0123456789876543210+    type instance Apply SFoo2Sym0 a0123456789876543210 = SFoo2 a0123456789876543210+    type SFoo4Sym1 (a0123456789876543210 :: Type) =+        SFoo4 a0123456789876543210+    instance SuppressUnusedWarnings SFoo4Sym0 where+      suppressUnusedWarnings = snd (((,) SFoo4Sym0KindInference) ())+    data SFoo4Sym0 :: (~>) Type Type+      where+        SFoo4Sym0KindInference :: forall a0123456789876543210+                                         arg. SameKind (Apply SFoo4Sym0 arg) (SFoo4Sym1 arg) =>+                                  SFoo4Sym0 a0123456789876543210+    type instance Apply SFoo4Sym0 a0123456789876543210 = SFoo4 a0123456789876543210+    class PSC (a :: Type)+    instance PSC a+    class SSC (a :: Type)+    instance SSC a
− tests/compile-and-dump/Singletons/T316.ghc86.template 
@@ -1,40 +0,0 @@-Singletons/T316.hs:(0,0)-(0,0): Splicing declarations-    promoteOnly-      [d| replaceAllGTypes :: (a -> Type -> a) -> [Type] -> [a] -> [a]-          replaceAllGTypes f types as = zipWith f as types |]-  ======>-    type ReplaceAllGTypesSym3 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) Type a0123456789876543210)) (a0123456789876543210 :: [Type]) (a0123456789876543210 :: [a0123456789876543210]) =-        ReplaceAllGTypes a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ReplaceAllGTypesSym2KindInference) ())-    data ReplaceAllGTypesSym2 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) Type a0123456789876543210)) (a0123456789876543210 :: [Type]) :: (~>) [a0123456789876543210] [a0123456789876543210]-      where-        ReplaceAllGTypesSym2KindInference :: forall a0123456789876543210-                                                    a0123456789876543210-                                                    a0123456789876543210-                                                    arg. 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-    instance SuppressUnusedWarnings (ReplaceAllGTypesSym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ReplaceAllGTypesSym1KindInference) ())-    data ReplaceAllGTypesSym1 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) Type a0123456789876543210)) :: (~>) [Type] ((~>) [a0123456789876543210] [a0123456789876543210])-      where-        ReplaceAllGTypesSym1KindInference :: forall a0123456789876543210-                                                    a0123456789876543210-                                                    arg. SameKind (Apply (ReplaceAllGTypesSym1 a0123456789876543210) arg) (ReplaceAllGTypesSym2 a0123456789876543210 arg) =>-                                             ReplaceAllGTypesSym1 a0123456789876543210 a0123456789876543210-    type instance Apply (ReplaceAllGTypesSym1 a0123456789876543210) a0123456789876543210 = ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ReplaceAllGTypesSym0 where-      suppressUnusedWarnings-        = snd (((,) ReplaceAllGTypesSym0KindInference) ())-    data ReplaceAllGTypesSym0 :: forall a0123456789876543210.-                                 (~>) ((~>) a0123456789876543210 ((~>) Type a0123456789876543210)) ((~>) [Type] ((~>) [a0123456789876543210] [a0123456789876543210]))-      where-        ReplaceAllGTypesSym0KindInference :: forall a0123456789876543210-                                                    arg. SameKind (Apply ReplaceAllGTypesSym0 arg) (ReplaceAllGTypesSym1 arg) =>-                                             ReplaceAllGTypesSym0 a0123456789876543210-    type instance Apply ReplaceAllGTypesSym0 a0123456789876543210 = ReplaceAllGTypesSym1 a0123456789876543210-    type family ReplaceAllGTypes (a :: (~>) a ((~>) Type a)) (a :: [Type]) (a :: [a]) :: [a] where-      ReplaceAllGTypes f types as = Apply (Apply (Apply ZipWithSym0 f) as) types
+ tests/compile-and-dump/Singletons/T316.ghc88.template view
@@ -0,0 +1,40 @@+Singletons/T316.hs:(0,0)-(0,0): Splicing declarations+    promoteOnly+      [d| replaceAllGTypes :: (a -> Type -> a) -> [Type] -> [a] -> [a]+          replaceAllGTypes f types as = zipWith f as types |]+  ======>+    type ReplaceAllGTypesSym3 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) Type a0123456789876543210)) (a0123456789876543210 :: [Type]) (a0123456789876543210 :: [a0123456789876543210]) =+        ReplaceAllGTypes a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ReplaceAllGTypesSym2KindInference) ())+    data ReplaceAllGTypesSym2 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) Type a0123456789876543210)) (a0123456789876543210 :: [Type]) :: (~>) [a0123456789876543210] [a0123456789876543210]+      where+        ReplaceAllGTypesSym2KindInference :: forall a0123456789876543210+                                                    a0123456789876543210+                                                    a0123456789876543210+                                                    arg. 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+    instance SuppressUnusedWarnings (ReplaceAllGTypesSym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ReplaceAllGTypesSym1KindInference) ())+    data ReplaceAllGTypesSym1 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) Type a0123456789876543210)) :: (~>) [Type] ((~>) [a0123456789876543210] [a0123456789876543210])+      where+        ReplaceAllGTypesSym1KindInference :: forall a0123456789876543210+                                                    a0123456789876543210+                                                    arg. SameKind (Apply (ReplaceAllGTypesSym1 a0123456789876543210) arg) (ReplaceAllGTypesSym2 a0123456789876543210 arg) =>+                                             ReplaceAllGTypesSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (ReplaceAllGTypesSym1 a0123456789876543210) a0123456789876543210 = ReplaceAllGTypesSym2 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ReplaceAllGTypesSym0 where+      suppressUnusedWarnings+        = snd (((,) ReplaceAllGTypesSym0KindInference) ())+    data ReplaceAllGTypesSym0 :: forall a0123456789876543210.+                                 (~>) ((~>) a0123456789876543210 ((~>) Type a0123456789876543210)) ((~>) [Type] ((~>) [a0123456789876543210] [a0123456789876543210]))+      where+        ReplaceAllGTypesSym0KindInference :: forall a0123456789876543210+                                                    arg. SameKind (Apply ReplaceAllGTypesSym0 arg) (ReplaceAllGTypesSym1 arg) =>+                                             ReplaceAllGTypesSym0 a0123456789876543210+    type instance Apply ReplaceAllGTypesSym0 a0123456789876543210 = ReplaceAllGTypesSym1 a0123456789876543210+    type family ReplaceAllGTypes (a :: (~>) a ((~>) Type a)) (a :: [Type]) (a :: [a]) :: [a] where+      ReplaceAllGTypes f types as = Apply (Apply (Apply ZipWithSym0 f) as) types
− tests/compile-and-dump/Singletons/T322.ghc86.template 
@@ -1,49 +0,0 @@-Singletons/T322.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| infixr 2 !-          -          (!) :: Bool -> Bool -> Bool-          (!) = (||) |]-  ======>-    (!) :: Bool -> Bool -> Bool-    (!) = (||)-    infixr 2 !-    type (!@#@$$$) (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) =-        (:!) a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings ((!@#@$$) a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) (:!@#@$$###)) ())-    data (!@#@$$) (a0123456789876543210 :: Bool) :: (~>) Bool Bool-      where-        (:!@#@$$###) :: forall a0123456789876543210-                               a0123456789876543210-                               arg. SameKind (Apply ((!@#@$$) a0123456789876543210) arg) ((!@#@$$$) a0123456789876543210 arg) =>-                        (!@#@$$) a0123456789876543210 a0123456789876543210-    type instance Apply ((!@#@$$) a0123456789876543210) a0123456789876543210 = (:!) a0123456789876543210 a0123456789876543210-    infixr 2 !@#@$$-    instance SuppressUnusedWarnings (!@#@$) where-      suppressUnusedWarnings = snd (((,) (:!@#@$###)) ())-    data (!@#@$) :: (~>) Bool ((~>) Bool Bool)-      where-        (:!@#@$###) :: forall a0123456789876543210-                              arg. SameKind (Apply (!@#@$) arg) ((!@#@$$) arg) =>-                       (!@#@$) a0123456789876543210-    type instance Apply (!@#@$) a0123456789876543210 = (!@#@$$) a0123456789876543210-    infixr 2 !@#@$-    type family (:!) (a :: Bool) (a :: Bool) :: Bool where-      (:!) a_0123456789876543210 a_0123456789876543210 = Apply (Apply (||@#@$) a_0123456789876543210) a_0123456789876543210-    infixr 2 :!-    infixr 2 %!-    (%!) ::-      forall (t :: Bool) (t :: Bool).-      Sing t -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: Bool)-    (%!)-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((applySing ((singFun2 @(||@#@$)) (%||))) sA_0123456789876543210))-          sA_0123456789876543210-    instance SingI ((!@#@$) :: (~>) Bool ((~>) Bool Bool)) where-      sing = (singFun2 @(!@#@$)) (%!)-    instance SingI d =>-             SingI ((!@#@$$) (d :: Bool) :: (~>) Bool Bool) where-      sing = (singFun1 @((!@#@$$) (d :: Bool))) ((%!) (sing @d))
+ tests/compile-and-dump/Singletons/T322.ghc88.template view
@@ -0,0 +1,48 @@+Singletons/T322.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| infixr 2 !+          +          (!) :: Bool -> Bool -> Bool+          (!) = (||) |]+  ======>+    (!) :: Bool -> Bool -> Bool+    (!) = (||)+    infixr 2 !+    type (!@#@$$$) (a0123456789876543210 :: Bool) (a0123456789876543210 :: Bool) =+        (!) a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings ((!@#@$$) a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) (:!@#@$$###)) ())+    data (!@#@$$) (a0123456789876543210 :: Bool) :: (~>) Bool Bool+      where+        (:!@#@$$###) :: forall a0123456789876543210+                               a0123456789876543210+                               arg. SameKind (Apply ((!@#@$$) a0123456789876543210) arg) ((!@#@$$$) a0123456789876543210 arg) =>+                        (!@#@$$) a0123456789876543210 a0123456789876543210+    type instance Apply ((!@#@$$) a0123456789876543210) a0123456789876543210 = (!) a0123456789876543210 a0123456789876543210+    infixr 2 !@#@$$+    instance SuppressUnusedWarnings (!@#@$) where+      suppressUnusedWarnings = snd (((,) (:!@#@$###)) ())+    data (!@#@$) :: (~>) Bool ((~>) Bool Bool)+      where+        (:!@#@$###) :: forall a0123456789876543210+                              arg. SameKind (Apply (!@#@$) arg) ((!@#@$$) arg) =>+                       (!@#@$) a0123456789876543210+    type instance Apply (!@#@$) a0123456789876543210 = (!@#@$$) a0123456789876543210+    infixr 2 !@#@$+    type family (!) (a :: Bool) (a :: Bool) :: Bool where+      (!) a_0123456789876543210 a_0123456789876543210 = Apply (Apply (||@#@$) a_0123456789876543210) a_0123456789876543210+    infixr 2 %!+    (%!) ::+      forall (t :: Bool) (t :: Bool).+      Sing t -> Sing t -> Sing (Apply (Apply (!@#@$) t) t :: Bool)+    (%!)+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing+           ((applySing ((singFun2 @(||@#@$)) (%||))) sA_0123456789876543210))+          sA_0123456789876543210+    instance SingI ((!@#@$) :: (~>) Bool ((~>) Bool Bool)) where+      sing = (singFun2 @(!@#@$)) (%!)+    instance SingI d =>+             SingI ((!@#@$$) (d :: Bool) :: (~>) Bool Bool) where+      sing = (singFun1 @((!@#@$$) (d :: Bool))) ((%!) (sing @d))
tests/compile-and-dump/Singletons/T322.hs view
@@ -9,5 +9,5 @@   infixr 2 !   |]) -f1 :: (False && True :! True) :~: True+f1 :: (False && True ! True) :~: True f1 = Refl
− tests/compile-and-dump/Singletons/T323.ghc86.template 
+ tests/compile-and-dump/Singletons/T323.ghc88.template view
− tests/compile-and-dump/Singletons/T33.ghc86.template 
@@ -1,36 +0,0 @@-Singletons/T33.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo :: (Bool, Bool) -> ()-          foo ~(_, _) = () |]-  ======>-    foo :: (Bool, Bool) -> ()-    foo ~(_, _) = ()-    type FooSym1 (a0123456789876543210 :: (Bool, Bool)) =-        Foo a0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: (~>) (Bool, Bool) ()-      where-        FooSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210-    type family Foo (a :: (Bool, Bool)) :: () where-      Foo '(_, _) = Tuple0Sym0-    sFoo ::-      forall (t :: (Bool, Bool)). Sing t -> Sing (Apply FooSym0 t :: ())-    sFoo (STuple2 _ _) = STuple0-    instance SingI (FooSym0 :: (~>) (Bool, Bool) ()) where-      sing = (singFun1 @FooSym0) sFoo--Singletons/T33.hs:0:0: warning:-    Lazy pattern converted into regular pattern in promotion-  |-6 | $(singletons [d|-  |   ^^^^^^^^^^^^^^...--Singletons/T33.hs:0:0: warning:-    Lazy pattern converted into regular pattern during singleton generation.-  |-6 | $(singletons [d|-  |   ^^^^^^^^^^^^^^...
+ tests/compile-and-dump/Singletons/T33.ghc88.template view
@@ -0,0 +1,36 @@+Singletons/T33.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo :: (Bool, Bool) -> ()+          foo ~(_, _) = () |]+  ======>+    foo :: (Bool, Bool) -> ()+    foo ~(_, _) = ()+    type FooSym1 (a0123456789876543210 :: (Bool, Bool)) =+        Foo a0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: (~>) (Bool, Bool) ()+      where+        FooSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 a0123456789876543210+    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210+    type family Foo (a :: (Bool, Bool)) :: () where+      Foo '(_, _) = Tuple0Sym0+    sFoo ::+      forall (t :: (Bool, Bool)). Sing t -> Sing (Apply FooSym0 t :: ())+    sFoo (STuple2 _ _) = STuple0+    instance SingI (FooSym0 :: (~>) (Bool, Bool) ()) where+      sing = (singFun1 @FooSym0) sFoo++Singletons/T33.hs:0:0: warning:+    Lazy pattern converted into regular pattern in promotion+  |+6 | $(singletons [d|+  |   ^^^^^^^^^^^^^^...++Singletons/T33.hs:0:0: warning:+    Lazy pattern converted into regular pattern during singleton generation.+  |+6 | $(singletons [d|+  |   ^^^^^^^^^^^^^^...
− tests/compile-and-dump/Singletons/T332.ghc86.template 
@@ -1,57 +0,0 @@-Singletons/T332.hs:(0,0)-(0,0): Splicing declarations-    promote-      [d| f :: Foo -> ()-          f MkFoo {} = ()-          -          data Foo = MkFoo |]-  ======>-    data Foo = MkFoo-    f :: Foo -> ()-    f MkFoo {} = ()-    type FSym1 (a0123456789876543210 :: Foo) = F a0123456789876543210-    instance SuppressUnusedWarnings FSym0 where-      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())-    data FSym0 :: (~>) Foo ()-      where-        FSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>-                              FSym0 a0123456789876543210-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210-    type family F (a :: Foo) :: () where-      F MkFoo = Tuple0Sym0-    type MkFooSym0 = MkFoo-Singletons/T332.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| b :: Bar -> ()-          b MkBar {} = ()-          -          data Bar = MkBar |]-  ======>-    data Bar = MkBar-    b :: Bar -> ()-    b MkBar {} = ()-    type MkBarSym0 = MkBar-    type BSym1 (a0123456789876543210 :: Bar) = B a0123456789876543210-    instance SuppressUnusedWarnings BSym0 where-      suppressUnusedWarnings = snd (((,) BSym0KindInference) ())-    data BSym0 :: (~>) Bar ()-      where-        BSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply BSym0 arg) (BSym1 arg) =>-                              BSym0 a0123456789876543210-    type instance Apply BSym0 a0123456789876543210 = B a0123456789876543210-    type family B (a :: Bar) :: () where-      B MkBar = Tuple0Sym0-    sB :: forall (t :: Bar). Sing t -> Sing (Apply BSym0 t :: ())-    sB SMkBar = STuple0-    instance SingI (BSym0 :: (~>) Bar ()) where-      sing = (singFun1 @BSym0) sB-    data instance Sing :: Bar -> GHC.Types.Type-      where SMkBar :: Sing MkBar-    type SBar = (Sing :: Bar -> GHC.Types.Type)-    instance SingKind Bar where-      type Demote Bar = Bar-      fromSing SMkBar = MkBar-      toSing MkBar = SomeSing SMkBar-    instance SingI MkBar where-      sing = SMkBar
+ tests/compile-and-dump/Singletons/T332.ghc88.template view
@@ -0,0 +1,56 @@+Singletons/T332.hs:(0,0)-(0,0): Splicing declarations+    promote+      [d| f :: Foo -> ()+          f MkFoo {} = ()+          +          data Foo = MkFoo |]+  ======>+    data Foo = MkFoo+    f :: Foo -> ()+    f MkFoo {} = ()+    type FSym1 (a0123456789876543210 :: Foo) = F a0123456789876543210+    instance SuppressUnusedWarnings FSym0 where+      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())+    data FSym0 :: (~>) Foo ()+      where+        FSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>+                              FSym0 a0123456789876543210+    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210+    type family F (a :: Foo) :: () where+      F MkFoo = Tuple0Sym0+    type MkFooSym0 = MkFoo+Singletons/T332.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| b :: Bar -> ()+          b MkBar {} = ()+          +          data Bar = MkBar |]+  ======>+    data Bar = MkBar+    b :: Bar -> ()+    b MkBar {} = ()+    type MkBarSym0 = MkBar+    type BSym1 (a0123456789876543210 :: Bar) = B a0123456789876543210+    instance SuppressUnusedWarnings BSym0 where+      suppressUnusedWarnings = snd (((,) BSym0KindInference) ())+    data BSym0 :: (~>) Bar ()+      where+        BSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply BSym0 arg) (BSym1 arg) =>+                              BSym0 a0123456789876543210+    type instance Apply BSym0 a0123456789876543210 = B a0123456789876543210+    type family B (a :: Bar) :: () where+      B MkBar = Tuple0Sym0+    sB :: forall (t :: Bar). Sing t -> Sing (Apply BSym0 t :: ())+    sB SMkBar = STuple0+    instance SingI (BSym0 :: (~>) Bar ()) where+      sing = (singFun1 @BSym0) sB+    data SBar :: Bar -> GHC.Types.Type where SMkBar :: SBar MkBar+    type instance Sing @Bar = SBar+    instance SingKind Bar where+      type Demote Bar = Bar+      fromSing SMkBar = MkBar+      toSing MkBar = SomeSing SMkBar+    instance SingI MkBar where+      sing = SMkBar
− tests/compile-and-dump/Singletons/T342.ghc86.template 
@@ -1,17 +0,0 @@-Singletons/T342.hs:(0,0)-(0,0): Splicing declarations-    do synName <- newName "MyId"-       a <- newName "a"-       let syn = TySynD synName [PlainTV a] (VarT a)-       defuns <- withLocalDeclarations [syn] $ genDefunSymbols [synName]-       pure $ syn : defuns-  ======>-    type MyId a = a-    type MyIdSym1 a0123456789876543210 = MyId a0123456789876543210-    instance SuppressUnusedWarnings MyIdSym0 where-      suppressUnusedWarnings = snd (((,) MyIdSym0KindInference) ())-    data MyIdSym0 a0123456789876543210-      where-        MyIdSym0KindInference :: forall a0123456789876543210-                                        arg. SameKind (Apply MyIdSym0 arg) (MyIdSym1 arg) =>-                                 MyIdSym0 a0123456789876543210-    type instance Apply MyIdSym0 a0123456789876543210 = MyId a0123456789876543210
+ tests/compile-and-dump/Singletons/T342.ghc88.template view
@@ -0,0 +1,17 @@+Singletons/T342.hs:(0,0)-(0,0): Splicing declarations+    do synName <- newName "MyId"+       a <- newName "a"+       let syn = TySynD synName [PlainTV a] (VarT a)+       defuns <- withLocalDeclarations [syn] $ genDefunSymbols [synName]+       pure $ syn : defuns+  ======>+    type MyId a = a+    type MyIdSym1 a0123456789876543210 = MyId a0123456789876543210+    instance SuppressUnusedWarnings MyIdSym0 where+      suppressUnusedWarnings = snd (((,) MyIdSym0KindInference) ())+    data MyIdSym0 a0123456789876543210+      where+        MyIdSym0KindInference :: forall a0123456789876543210+                                        arg. SameKind (Apply MyIdSym0 arg) (MyIdSym1 arg) =>+                                 MyIdSym0 a0123456789876543210+    type instance Apply MyIdSym0 a0123456789876543210 = MyId a0123456789876543210
− tests/compile-and-dump/Singletons/T353.ghc86.template 
@@ -1,104 +0,0 @@-Singletons/T353.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| type family Symmetry (a :: Proxy t) (y :: Proxy t) (e :: (a :: Proxy (t :: k))-                                                                   :~:-                                                                   (y :: Proxy (t :: k))) :: Type where-            Symmetry a y _ = y :~: a |]-  ======>-    type family Symmetry (a :: Proxy t) (y :: Proxy t) (e :: (:~:) (a :: Proxy (t :: k)) (y :: Proxy (t :: k))) :: Type where-      Symmetry a y _ = (:~:) y a-    type SymmetrySym3 (a0123456789876543210 :: Proxy t0123456789876543210) (y0123456789876543210 :: Proxy t0123456789876543210) (e0123456789876543210 :: (:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) =-        Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210-    instance SuppressUnusedWarnings (SymmetrySym2 y0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) SymmetrySym2KindInference) ())-    data SymmetrySym2 (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) :: (~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type-      where-        SymmetrySym2KindInference :: forall a0123456789876543210-                                            y0123456789876543210-                                            e0123456789876543210-                                            arg. SameKind (Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) arg) (SymmetrySym3 a0123456789876543210 y0123456789876543210 arg) =>-                                     SymmetrySym2 a0123456789876543210 y0123456789876543210 e0123456789876543210-    type instance Apply (SymmetrySym2 y0123456789876543210 a0123456789876543210) e0123456789876543210 = Symmetry y0123456789876543210 a0123456789876543210 e0123456789876543210-    instance SuppressUnusedWarnings (SymmetrySym1 a0123456789876543210) where-      suppressUnusedWarnings = snd (((,) SymmetrySym1KindInference) ())-    data SymmetrySym1 (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) :: forall (y0123456789876543210 :: Proxy t0123456789876543210).-                                                                                                        (~>) (Proxy t0123456789876543210) ((~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type)-      where-        SymmetrySym1KindInference :: forall a0123456789876543210-                                            y0123456789876543210-                                            arg. SameKind (Apply (SymmetrySym1 a0123456789876543210) arg) (SymmetrySym2 a0123456789876543210 arg) =>-                                     SymmetrySym1 a0123456789876543210 y0123456789876543210-    type instance Apply (SymmetrySym1 a0123456789876543210) y0123456789876543210 = SymmetrySym2 a0123456789876543210 y0123456789876543210-    instance SuppressUnusedWarnings SymmetrySym0 where-      suppressUnusedWarnings = snd (((,) SymmetrySym0KindInference) ())-    data SymmetrySym0 :: forall k0123456789876543210-                                (t0123456789876543210 :: k0123456789876543210)-                                (a0123456789876543210 :: Proxy t0123456789876543210)-                                (y0123456789876543210 :: Proxy t0123456789876543210).-                         (~>) (Proxy t0123456789876543210) ((~>) (Proxy t0123456789876543210) ((~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type))-      where-        SymmetrySym0KindInference :: forall a0123456789876543210-                                            arg. SameKind (Apply SymmetrySym0 arg) (SymmetrySym1 arg) =>-                                     SymmetrySym0 a0123456789876543210-    type instance Apply SymmetrySym0 a0123456789876543210 = SymmetrySym1 a0123456789876543210-Singletons/T353.hs:0:0:: Splicing declarations-    genDefunSymbols [''Prod]-  ======>-    type MkProdSym2 (t0123456789876543210 :: f0123456789876543210 p0123456789876543210) (t0123456789876543210 :: g0123456789876543210 p0123456789876543210) =-         'MkProd t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkProdSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkProdSym1KindInference) ())-    data MkProdSym1 (t0123456789876543210 :: (f0123456789876543210 :: k0123456789876543210-                                                                      -> Type) (p0123456789876543210 :: k0123456789876543210)) :: forall (g0123456789876543210 :: k0123456789876543210-                                                                                                                                                                  -> Type).-                                                                                                                                  (~>) (g0123456789876543210 p0123456789876543210) (Prod (f0123456789876543210 :: k0123456789876543210-                                                                                                                                                                                                                  -> Type) (g0123456789876543210 :: k0123456789876543210-                                                                                                                                                                                                                                                    -> Type) (p0123456789876543210 :: k0123456789876543210))-      where-        MkProdSym1KindInference :: forall t0123456789876543210-                                          t0123456789876543210-                                          arg. SameKind (Apply (MkProdSym1 t0123456789876543210) arg) (MkProdSym2 t0123456789876543210 arg) =>-                                   MkProdSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (MkProdSym1 t0123456789876543210) t0123456789876543210 =  'MkProd t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings MkProdSym0 where-      suppressUnusedWarnings = snd (((,) MkProdSym0KindInference) ())-    data MkProdSym0 :: forall k0123456789876543210-                              (f0123456789876543210 :: k0123456789876543210 -> Type)-                              (g0123456789876543210 :: k0123456789876543210 -> Type)-                              (p0123456789876543210 :: k0123456789876543210).-                       (~>) (f0123456789876543210 p0123456789876543210) ((~>) (g0123456789876543210 p0123456789876543210) (Prod (f0123456789876543210 :: k0123456789876543210-                                                                                                                                                         -> Type) (g0123456789876543210 :: k0123456789876543210-                                                                                                                                                                                           -> Type) (p0123456789876543210 :: k0123456789876543210)))-      where-        MkProdSym0KindInference :: forall t0123456789876543210-                                          arg. SameKind (Apply MkProdSym0 arg) (MkProdSym1 arg) =>-                                   MkProdSym0 t0123456789876543210-    type instance Apply MkProdSym0 t0123456789876543210 = MkProdSym1 t0123456789876543210-Singletons/T353.hs:0:0:: Splicing declarations-    genDefunSymbols [''Foo]-  ======>-    type MkFooSym2 (t0123456789876543210 :: Proxy a0123456789876543210) (t0123456789876543210 :: Proxy b0123456789876543210) =-         'MkFoo t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (MkFooSym1 t0123456789876543210) where-      suppressUnusedWarnings = snd (((,) MkFooSym1KindInference) ())-    data MkFooSym1 (t0123456789876543210 :: Proxy (a0123456789876543210 :: k0123456789876543210)) :: forall k0123456789876543210-                                                                                                            (b0123456789876543210 :: k0123456789876543210).-                                                                                                     (~>) (Proxy b0123456789876543210) (Foo (a0123456789876543210 :: k0123456789876543210) (b0123456789876543210 :: k0123456789876543210))-      where-        MkFooSym1KindInference :: forall t0123456789876543210-                                         t0123456789876543210-                                         arg. SameKind (Apply (MkFooSym1 t0123456789876543210) arg) (MkFooSym2 t0123456789876543210 arg) =>-                                  MkFooSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (MkFooSym1 t0123456789876543210) t0123456789876543210 =  'MkFoo t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings MkFooSym0 where-      suppressUnusedWarnings = snd (((,) MkFooSym0KindInference) ())-    data MkFooSym0 :: forall k0123456789876543210-                             (a0123456789876543210 :: k0123456789876543210)-                             k0123456789876543210-                             (b0123456789876543210 :: k0123456789876543210).-                      (~>) (Proxy a0123456789876543210) ((~>) (Proxy b0123456789876543210) (Foo (a0123456789876543210 :: k0123456789876543210) (b0123456789876543210 :: k0123456789876543210)))-      where-        MkFooSym0KindInference :: forall t0123456789876543210-                                         arg. SameKind (Apply MkFooSym0 arg) (MkFooSym1 arg) =>-                                  MkFooSym0 t0123456789876543210-    type instance Apply MkFooSym0 t0123456789876543210 = MkFooSym1 t0123456789876543210
+ tests/compile-and-dump/Singletons/T353.ghc88.template view
@@ -0,0 +1,104 @@+Singletons/T353.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| type family Symmetry (a :: Proxy t) (y :: Proxy t) (e :: (a :: Proxy (t :: k))+                                                                   :~:+                                                                   (y :: Proxy (t :: k))) :: Type where+            Symmetry a y _ = y :~: a |]+  ======>+    type family Symmetry (a :: Proxy t) (y :: Proxy t) (e :: (:~:) (a :: Proxy (t :: k)) (y :: Proxy (t :: k))) :: Type where+      Symmetry a y _ = (:~:) y a+    type SymmetrySym3 (a0123456789876543210 :: Proxy t0123456789876543210) (y0123456789876543210 :: Proxy t0123456789876543210) (e0123456789876543210 :: (:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) =+        Symmetry a0123456789876543210 y0123456789876543210 e0123456789876543210+    instance SuppressUnusedWarnings (SymmetrySym2 y0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) SymmetrySym2KindInference) ())+    data SymmetrySym2 (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) :: (~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type+      where+        SymmetrySym2KindInference :: forall a0123456789876543210+                                            y0123456789876543210+                                            e0123456789876543210+                                            arg. SameKind (Apply (SymmetrySym2 a0123456789876543210 y0123456789876543210) arg) (SymmetrySym3 a0123456789876543210 y0123456789876543210 arg) =>+                                     SymmetrySym2 a0123456789876543210 y0123456789876543210 e0123456789876543210+    type instance Apply (SymmetrySym2 y0123456789876543210 a0123456789876543210) e0123456789876543210 = Symmetry y0123456789876543210 a0123456789876543210 e0123456789876543210+    instance SuppressUnusedWarnings (SymmetrySym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) SymmetrySym1KindInference) ())+    data SymmetrySym1 (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) :: forall (y0123456789876543210 :: Proxy t0123456789876543210).+                                                                                                        (~>) (Proxy t0123456789876543210) ((~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type)+      where+        SymmetrySym1KindInference :: forall a0123456789876543210+                                            y0123456789876543210+                                            arg. SameKind (Apply (SymmetrySym1 a0123456789876543210) arg) (SymmetrySym2 a0123456789876543210 arg) =>+                                     SymmetrySym1 a0123456789876543210 y0123456789876543210+    type instance Apply (SymmetrySym1 a0123456789876543210) y0123456789876543210 = SymmetrySym2 a0123456789876543210 y0123456789876543210+    instance SuppressUnusedWarnings SymmetrySym0 where+      suppressUnusedWarnings = snd (((,) SymmetrySym0KindInference) ())+    data SymmetrySym0 :: forall k0123456789876543210+                                (t0123456789876543210 :: k0123456789876543210)+                                (a0123456789876543210 :: Proxy t0123456789876543210)+                                (y0123456789876543210 :: Proxy t0123456789876543210).+                         (~>) (Proxy t0123456789876543210) ((~>) (Proxy t0123456789876543210) ((~>) ((:~:) (a0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210)) (y0123456789876543210 :: Proxy (t0123456789876543210 :: k0123456789876543210))) Type))+      where+        SymmetrySym0KindInference :: forall a0123456789876543210+                                            arg. SameKind (Apply SymmetrySym0 arg) (SymmetrySym1 arg) =>+                                     SymmetrySym0 a0123456789876543210+    type instance Apply SymmetrySym0 a0123456789876543210 = SymmetrySym1 a0123456789876543210+Singletons/T353.hs:0:0:: Splicing declarations+    genDefunSymbols [''Prod]+  ======>+    type MkProdSym2 (t0123456789876543210 :: f0123456789876543210 p0123456789876543210) (t0123456789876543210 :: g0123456789876543210 p0123456789876543210) =+        'MkProd t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkProdSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkProdSym1KindInference) ())+    data MkProdSym1 (t0123456789876543210 :: (f0123456789876543210 :: k0123456789876543210+                                                                      -> Type) (p0123456789876543210 :: k0123456789876543210)) :: forall (g0123456789876543210 :: k0123456789876543210+                                                                                                                                                                  -> Type).+                                                                                                                                  (~>) (g0123456789876543210 p0123456789876543210) (Prod (f0123456789876543210 :: k0123456789876543210+                                                                                                                                                                                                                  -> Type) (g0123456789876543210 :: k0123456789876543210+                                                                                                                                                                                                                                                    -> Type) (p0123456789876543210 :: k0123456789876543210))+      where+        MkProdSym1KindInference :: forall t0123456789876543210+                                          t0123456789876543210+                                          arg. SameKind (Apply (MkProdSym1 t0123456789876543210) arg) (MkProdSym2 t0123456789876543210 arg) =>+                                   MkProdSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (MkProdSym1 t0123456789876543210) t0123456789876543210 = 'MkProd t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings MkProdSym0 where+      suppressUnusedWarnings = snd (((,) MkProdSym0KindInference) ())+    data MkProdSym0 :: forall k0123456789876543210+                              (f0123456789876543210 :: k0123456789876543210 -> Type)+                              (p0123456789876543210 :: k0123456789876543210)+                              (g0123456789876543210 :: k0123456789876543210 -> Type).+                       (~>) (f0123456789876543210 p0123456789876543210) ((~>) (g0123456789876543210 p0123456789876543210) (Prod (f0123456789876543210 :: k0123456789876543210+                                                                                                                                                         -> Type) (g0123456789876543210 :: k0123456789876543210+                                                                                                                                                                                           -> Type) (p0123456789876543210 :: k0123456789876543210)))+      where+        MkProdSym0KindInference :: forall t0123456789876543210+                                          arg. SameKind (Apply MkProdSym0 arg) (MkProdSym1 arg) =>+                                   MkProdSym0 t0123456789876543210+    type instance Apply MkProdSym0 t0123456789876543210 = MkProdSym1 t0123456789876543210+Singletons/T353.hs:0:0:: Splicing declarations+    genDefunSymbols [''Foo]+  ======>+    type MkFooSym2 (t0123456789876543210 :: Proxy a0123456789876543210) (t0123456789876543210 :: Proxy b0123456789876543210) =+        'MkFoo t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (MkFooSym1 t0123456789876543210) where+      suppressUnusedWarnings = snd (((,) MkFooSym1KindInference) ())+    data MkFooSym1 (t0123456789876543210 :: Proxy (a0123456789876543210 :: k0123456789876543210)) :: forall k0123456789876543210+                                                                                                            (b0123456789876543210 :: k0123456789876543210).+                                                                                                     (~>) (Proxy b0123456789876543210) (Foo (a0123456789876543210 :: k0123456789876543210) (b0123456789876543210 :: k0123456789876543210))+      where+        MkFooSym1KindInference :: forall t0123456789876543210+                                         t0123456789876543210+                                         arg. SameKind (Apply (MkFooSym1 t0123456789876543210) arg) (MkFooSym2 t0123456789876543210 arg) =>+                                  MkFooSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (MkFooSym1 t0123456789876543210) t0123456789876543210 = 'MkFoo t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings MkFooSym0 where+      suppressUnusedWarnings = snd (((,) MkFooSym0KindInference) ())+    data MkFooSym0 :: forall k0123456789876543210+                             (a0123456789876543210 :: k0123456789876543210)+                             k0123456789876543210+                             (b0123456789876543210 :: k0123456789876543210).+                      (~>) (Proxy a0123456789876543210) ((~>) (Proxy b0123456789876543210) (Foo (a0123456789876543210 :: k0123456789876543210) (b0123456789876543210 :: k0123456789876543210)))+      where+        MkFooSym0KindInference :: forall t0123456789876543210+                                         arg. SameKind (Apply MkFooSym0 arg) (MkFooSym1 arg) =>+                                  MkFooSym0 t0123456789876543210+    type instance Apply MkFooSym0 t0123456789876543210 = MkFooSym1 t0123456789876543210
− tests/compile-and-dump/Singletons/T358.ghc86.template 
@@ -1,118 +0,0 @@-Singletons/T358.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| class C1 (f :: k -> Type) where-            method1 :: f a-          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 _ = [] |]-  ======>-    class C1 (f :: k -> Type) where-      method1 :: f a-    instance C1 [] where-      method1 :: [a]-      method1 = []-    class C2 a where-      method2a :: forall b. b -> a-      method2b :: forall b. b -> a-    instance C2 [a] where-      method2b :: forall b. b -> [a]-      method2a _ = []-      method2b _ = []-    type Method1Sym0 = Method1-    class PC1 (f :: k -> Type) where-      type Method1 :: f a-    type Method2aSym1 (arg0123456789876543210 :: b0123456789876543210) =-        Method2a arg0123456789876543210-    instance SuppressUnusedWarnings Method2aSym0 where-      suppressUnusedWarnings = snd (((,) Method2aSym0KindInference) ())-    data Method2aSym0 :: forall a0123456789876543210-                                b0123456789876543210.-                         (~>) b0123456789876543210 a0123456789876543210-      where-        Method2aSym0KindInference :: forall arg0123456789876543210-                                            arg. SameKind (Apply Method2aSym0 arg) (Method2aSym1 arg) =>-                                     Method2aSym0 arg0123456789876543210-    type instance Apply Method2aSym0 arg0123456789876543210 = Method2a arg0123456789876543210-    type Method2bSym1 (arg0123456789876543210 :: b0123456789876543210) =-        Method2b arg0123456789876543210-    instance SuppressUnusedWarnings Method2bSym0 where-      suppressUnusedWarnings = snd (((,) Method2bSym0KindInference) ())-    data Method2bSym0 :: forall a0123456789876543210-                                b0123456789876543210.-                         (~>) b0123456789876543210 a0123456789876543210-      where-        Method2bSym0KindInference :: forall arg0123456789876543210-                                            arg. SameKind (Apply Method2bSym0 arg) (Method2bSym1 arg) =>-                                     Method2bSym0 arg0123456789876543210-    type instance Apply Method2bSym0 arg0123456789876543210 = Method2b arg0123456789876543210-    class PC2 (a :: Type) where-      type Method2a (arg :: b) :: a-      type Method2b (arg :: b) :: a-    type family Method1_0123456789876543210 :: [a] where-      Method1_0123456789876543210 = '[]-    type Method1_0123456789876543210Sym0 = Method1_0123456789876543210-    instance PC1 [] where-      type Method1 = Method1_0123456789876543210Sym0-    type family Method2a_0123456789876543210 (a :: b) :: [a] where-      Method2a_0123456789876543210 _ = '[]-    type Method2a_0123456789876543210Sym1 (a0123456789876543210 :: b0123456789876543210) =-        Method2a_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Method2a_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Method2a_0123456789876543210Sym0KindInference) ())-    data Method2a_0123456789876543210Sym0 :: forall a0123456789876543210-                                                    b0123456789876543210.-                                             (~>) b0123456789876543210 [a0123456789876543210]-      where-        Method2a_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply Method2a_0123456789876543210Sym0 arg) (Method2a_0123456789876543210Sym1 arg) =>-                                                         Method2a_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Method2a_0123456789876543210Sym0 a0123456789876543210 = Method2a_0123456789876543210 a0123456789876543210-    type family Method2b_0123456789876543210 (a :: b) :: [a] where-      Method2b_0123456789876543210 _ = '[]-    type Method2b_0123456789876543210Sym1 (a0123456789876543210 :: b0123456789876543210) =-        Method2b_0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings Method2b_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) Method2b_0123456789876543210Sym0KindInference) ())-    data Method2b_0123456789876543210Sym0 :: forall a0123456789876543210-                                                    b0123456789876543210.-                                             (~>) b0123456789876543210 [a0123456789876543210]-      where-        Method2b_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                arg. SameKind (Apply Method2b_0123456789876543210Sym0 arg) (Method2b_0123456789876543210Sym1 arg) =>-                                                         Method2b_0123456789876543210Sym0 a0123456789876543210-    type instance Apply Method2b_0123456789876543210Sym0 a0123456789876543210 = Method2b_0123456789876543210 a0123456789876543210-    instance PC2 [a] where-      type Method2a a = Apply Method2a_0123456789876543210Sym0 a-      type Method2b a = Apply Method2b_0123456789876543210Sym0 a-    class SC1 (f :: k -> Type) where-      sMethod1 :: forall a. Sing (Method1Sym0 :: f a)-    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)-    instance SC1 [] where-      sMethod1 :: forall a. Sing (Method1Sym0 :: [a])-      sMethod1 = Data.Singletons.Prelude.Instances.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])-      sMethod2a _-        = Data.Singletons.Prelude.Instances.SNil-      sMethod2b _-        = Data.Singletons.Prelude.Instances.SNil-    instance SC2 a => SingI (Method2aSym0 :: (~>) b a) where-      sing = (singFun1 @Method2aSym0) sMethod2a-    instance SC2 a => SingI (Method2bSym0 :: (~>) b a) where-      sing = (singFun1 @Method2bSym0) sMethod2b
+ tests/compile-and-dump/Singletons/T358.ghc88.template view
@@ -0,0 +1,116 @@+Singletons/T358.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| class C1 (f :: k -> Type) where+            method1 :: f a+          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 _ = [] |]+  ======>+    class C1 (f :: k -> Type) where+      method1 :: f a+    instance C1 [] where+      method1 :: [a]+      method1 = []+    class C2 a where+      method2a :: forall b. b -> a+      method2b :: forall b. b -> a+    instance C2 [a] where+      method2b :: forall b. b -> [a]+      method2a _ = []+      method2b _ = []+    type Method1Sym0 = Method1+    class PC1 (f :: k -> Type) where+      type Method1 :: f a+    type Method2aSym1 (arg0123456789876543210 :: b0123456789876543210) =+        Method2a arg0123456789876543210+    instance SuppressUnusedWarnings Method2aSym0 where+      suppressUnusedWarnings = snd (((,) Method2aSym0KindInference) ())+    data Method2aSym0 :: forall b0123456789876543210+                                a0123456789876543210.+                         (~>) b0123456789876543210 a0123456789876543210+      where+        Method2aSym0KindInference :: forall arg0123456789876543210+                                            arg. SameKind (Apply Method2aSym0 arg) (Method2aSym1 arg) =>+                                     Method2aSym0 arg0123456789876543210+    type instance Apply Method2aSym0 arg0123456789876543210 = Method2a arg0123456789876543210+    type Method2bSym1 (arg0123456789876543210 :: b0123456789876543210) =+        Method2b arg0123456789876543210+    instance SuppressUnusedWarnings Method2bSym0 where+      suppressUnusedWarnings = snd (((,) Method2bSym0KindInference) ())+    data Method2bSym0 :: forall b0123456789876543210+                                a0123456789876543210.+                         (~>) b0123456789876543210 a0123456789876543210+      where+        Method2bSym0KindInference :: forall arg0123456789876543210+                                            arg. SameKind (Apply Method2bSym0 arg) (Method2bSym1 arg) =>+                                     Method2bSym0 arg0123456789876543210+    type instance Apply Method2bSym0 arg0123456789876543210 = Method2b arg0123456789876543210+    class PC2 (a :: Type) where+      type Method2a (arg :: b) :: a+      type Method2b (arg :: b) :: a+    type family Method1_0123456789876543210 :: [a] where+      Method1_0123456789876543210 = '[]+    type Method1_0123456789876543210Sym0 = Method1_0123456789876543210+    instance PC1 [] where+      type Method1 = Method1_0123456789876543210Sym0+    type family Method2a_0123456789876543210 (a :: b) :: [a] where+      Method2a_0123456789876543210 _ = '[]+    type Method2a_0123456789876543210Sym1 (a0123456789876543210 :: b0123456789876543210) =+        Method2a_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Method2a_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Method2a_0123456789876543210Sym0KindInference) ())+    data Method2a_0123456789876543210Sym0 :: forall b0123456789876543210+                                                    a0123456789876543210.+                                             (~>) b0123456789876543210 [a0123456789876543210]+      where+        Method2a_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply Method2a_0123456789876543210Sym0 arg) (Method2a_0123456789876543210Sym1 arg) =>+                                                         Method2a_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Method2a_0123456789876543210Sym0 a0123456789876543210 = Method2a_0123456789876543210 a0123456789876543210+    type family Method2b_0123456789876543210 (a :: b) :: [a] where+      Method2b_0123456789876543210 _ = '[]+    type Method2b_0123456789876543210Sym1 (a0123456789876543210 :: b0123456789876543210) =+        Method2b_0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings Method2b_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) Method2b_0123456789876543210Sym0KindInference) ())+    data Method2b_0123456789876543210Sym0 :: forall b0123456789876543210+                                                    a0123456789876543210.+                                             (~>) b0123456789876543210 [a0123456789876543210]+      where+        Method2b_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                arg. SameKind (Apply Method2b_0123456789876543210Sym0 arg) (Method2b_0123456789876543210Sym1 arg) =>+                                                         Method2b_0123456789876543210Sym0 a0123456789876543210+    type instance Apply Method2b_0123456789876543210Sym0 a0123456789876543210 = Method2b_0123456789876543210 a0123456789876543210+    instance PC2 [a] where+      type Method2a a = Apply Method2a_0123456789876543210Sym0 a+      type Method2b a = Apply Method2b_0123456789876543210Sym0 a+    class SC1 (f :: k -> Type) where+      sMethod1 :: forall a. Sing (Method1Sym0 :: f a)+    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)+    instance SC1 [] where+      sMethod1 :: forall a. Sing (Method1Sym0 :: [a])+      sMethod1 = Data.Singletons.Prelude.Instances.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])+      sMethod2a _ = Data.Singletons.Prelude.Instances.SNil+      sMethod2b _ = Data.Singletons.Prelude.Instances.SNil+    instance SC2 a => SingI (Method2aSym0 :: (~>) b a) where+      sing = (singFun1 @Method2aSym0) sMethod2a+    instance SC2 a => SingI (Method2bSym0 :: (~>) b a) where+      sing = (singFun1 @Method2bSym0) sMethod2b
+ tests/compile-and-dump/Singletons/T367.ghc88.template view
@@ -0,0 +1,39 @@+Singletons/T367.hs:(0,0)-(0,0): Splicing declarations+    singletonsOnly+      [d| const' :: a -> b -> a+          const' x _ = x |]+  ======>+    type Const'Sym2 (a0123456789876543210 :: a0123456789876543210) (a0123456789876543210 :: b0123456789876543210) =+        Const' a0123456789876543210 a0123456789876543210+    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings (Const'Sym1 a0123456789876543210) where+      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings+        = snd (((,) Const'Sym1KindInference) ())+    data Const'Sym1 (a0123456789876543210 :: a0123456789876543210) :: forall b0123456789876543210.+                                                                      (~>) b0123456789876543210 a0123456789876543210+      where+        Const'Sym1KindInference :: forall a0123456789876543210+                                          a0123456789876543210+                                          arg. SameKind (Apply (Const'Sym1 a0123456789876543210) arg) (Const'Sym2 a0123456789876543210 arg) =>+                                   Const'Sym1 a0123456789876543210 a0123456789876543210+    type instance Apply (Const'Sym1 a0123456789876543210) a0123456789876543210 = Const' a0123456789876543210 a0123456789876543210+    instance Data.Singletons.SuppressUnusedWarnings.SuppressUnusedWarnings Const'Sym0 where+      Data.Singletons.SuppressUnusedWarnings.suppressUnusedWarnings+        = snd (((,) Const'Sym0KindInference) ())+    data Const'Sym0 :: forall a0123456789876543210+                              b0123456789876543210.+                       (~>) a0123456789876543210 ((~>) b0123456789876543210 a0123456789876543210)+      where+        Const'Sym0KindInference :: forall a0123456789876543210+                                          arg. SameKind (Apply Const'Sym0 arg) (Const'Sym1 arg) =>+                                   Const'Sym0 a0123456789876543210+    type instance Apply Const'Sym0 a0123456789876543210 = Const'Sym1 a0123456789876543210+    type family Const' (a :: a) (a :: b) :: a where+      Const' x _ = x+    sConst' ::+      forall a b (t :: a) (t :: b).+      Sing t -> Sing t -> Sing (Apply (Apply Const'Sym0 t) t :: a)+    sConst' (sX :: Sing x) _ = sX+    instance SingI (Const'Sym0 :: (~>) a ((~>) b a)) where+      sing = (singFun2 @Const'Sym0) sConst'+    instance SingI d => SingI (Const'Sym1 (d :: a) :: (~>) b a) where+      sing = (singFun1 @(Const'Sym1 (d :: a))) (sConst' (sing @d))
+ tests/compile-and-dump/Singletons/T367.hs view
@@ -0,0 +1,12 @@+module T367 where++import Data.Singletons.Prelude+import Data.Singletons.TH (singletonsOnly)++$(singletonsOnly [d|+  const' :: a -> b -> a+  const' x _ = x+  |])++test :: Sing True+test = sConst' @Bool @() STrue STuple0
− tests/compile-and-dump/Singletons/T371.ghc86.template 
@@ -1,233 +0,0 @@-Singletons/T371.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Y (a :: Type)-            = Y1 | Y2 (X a)-            deriving Show-          data X (a :: Type)-            = X1 | X2 (Y a)-            deriving Show |]-  ======>-    data X (a :: Type)-      = X1 | X2 (Y a)-      deriving Show-    data Y (a :: Type)-      = Y1 | Y2 (X a)-      deriving Show-    type X1Sym0 = X1-    type X2Sym1 (t0123456789876543210 :: Y a0123456789876543210) =-        X2 t0123456789876543210-    instance SuppressUnusedWarnings X2Sym0 where-      suppressUnusedWarnings = snd (((,) X2Sym0KindInference) ())-    data X2Sym0 :: forall (a0123456789876543210 :: Type).-                   (~>) (Y a0123456789876543210) (X (a0123456789876543210 :: Type))-      where-        X2Sym0KindInference :: forall t0123456789876543210-                                      arg. SameKind (Apply X2Sym0 arg) (X2Sym1 arg) =>-                               X2Sym0 t0123456789876543210-    type instance Apply X2Sym0 t0123456789876543210 = X2 t0123456789876543210-    type Y1Sym0 = Y1-    type Y2Sym1 (t0123456789876543210 :: X a0123456789876543210) =-        Y2 t0123456789876543210-    instance SuppressUnusedWarnings Y2Sym0 where-      suppressUnusedWarnings = snd (((,) Y2Sym0KindInference) ())-    data Y2Sym0 :: forall (a0123456789876543210 :: Type).-                   (~>) (X a0123456789876543210) (Y (a0123456789876543210 :: Type))-      where-        Y2Sym0KindInference :: forall t0123456789876543210-                                      arg. SameKind (Apply Y2Sym0 arg) (Y2Sym1 arg) =>-                               Y2Sym0 t0123456789876543210-    type instance Apply Y2Sym0 t0123456789876543210 = Y2 t0123456789876543210-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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) (Data.Singletons.Prelude.Num.FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "X2 ")) (Apply (Apply ShowsPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210-    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: X a0123456789876543210) (a0123456789876543210 :: GHC.Types.Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: X a0123456789876543210) :: (~>) GHC.Types.Symbol GHC.Types.Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.-                                                                                      (~>) (X a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.-                                              (~>) GHC.Types.Nat ((~>) (X a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow (X a) where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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) (Data.Singletons.Prelude.Num.FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Y2 ")) (Apply (Apply ShowsPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210-    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Y a0123456789876543210) (a0123456789876543210 :: GHC.Types.Symbol) =-        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210-    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())-    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Y a0123456789876543210) :: (~>) GHC.Types.Symbol GHC.Types.Symbol-      where-        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())-    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.-                                                                                      (~>) (Y a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol)-      where-        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210-                                                                 a0123456789876543210-                                                                 arg. 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_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())-    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.-                                              (~>) GHC.Types.Nat ((~>) (Y a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol))-      where-        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210-                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>-                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210-    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210-    instance PShow (Y a) where-      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a-    data instance Sing :: X a -> Type-      where-        SX1 :: Sing X1-        SX2 :: forall a (n :: Y a). (Sing (n :: Y a)) -> Sing (X2 n)-    type SX = (Sing :: X a -> Type)-    instance SingKind a => SingKind (X a) where-      type Demote (X a) = X (Demote a)-      fromSing SX1 = X1-      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) }-    data instance Sing :: Y a -> Type-      where-        SY1 :: Sing Y1-        SY2 :: forall a (n :: X a). (Sing (n :: X a)) -> Sing (Y2 n)-    type SY = (Sing :: Y a -> Type)-    instance SingKind a => SingKind (Y a) where-      type Demote (Y a) = Y (Demote a)-      fromSing SY1 = Y1-      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) }-    instance SShow (Y a) => SShow (X a) where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: X a) (t3 :: GHC.Types.Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))-                                                             -> Type) t1) t2) t3)-      sShowsPrec-        _-        SX1-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "X1")))-            sA_0123456789876543210-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SX2 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "X2 "))))-                   ((applySing-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                          (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 11))))-                      sArg_0123456789876543210))))-            sA_0123456789876543210-    instance SShow (X a) => SShow (Y a) where-      sShowsPrec ::-        forall (t1 :: GHC.Types.Nat) (t2 :: Y a) (t3 :: GHC.Types.Symbol).-        Sing t1-        -> Sing t2-           -> Sing t3-              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))-                                                             -> Type) t1) t2) t3)-      sShowsPrec-        _-        SY1-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing ((singFun2 @ShowStringSym0) sShowString))-                (sing :: Sing "Y1")))-            sA_0123456789876543210-      sShowsPrec-        (sP_0123456789876543210 :: Sing p_0123456789876543210)-        (SY2 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))-        (sA_0123456789876543210 :: Sing a_0123456789876543210)-        = (applySing-             ((applySing-                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))-                    ((applySing-                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))-                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 10)))))-                ((applySing-                    ((applySing ((singFun3 @(.@#@$)) (%.)))-                       ((applySing ((singFun2 @ShowStringSym0) sShowString))-                          (sing :: Sing "Y2 "))))-                   ((applySing-                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))-                          (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 11))))-                      sArg_0123456789876543210))))-            sA_0123456789876543210-    deriving instance Data.Singletons.ShowSing.ShowSing (Y a) =>-                      Show (Sing (z :: X a))-    deriving instance Data.Singletons.ShowSing.ShowSing (X a) =>-                      Show (Sing (z :: Y a))-    instance SingI X1 where-      sing = SX1-    instance SingI n => SingI (X2 (n :: Y a)) where-      sing = SX2 sing-    instance SingI (X2Sym0 :: (~>) (Y a) (X (a :: Type))) where-      sing = (singFun1 @X2Sym0) SX2-    instance SingI (TyCon1 X2 :: (~>) (Y a) (X (a :: Type))) where-      sing = (singFun1 @(TyCon1 X2)) SX2-    instance SingI Y1 where-      sing = SY1-    instance SingI n => SingI (Y2 (n :: X a)) where-      sing = SY2 sing-    instance SingI (Y2Sym0 :: (~>) (X a) (Y (a :: Type))) where-      sing = (singFun1 @Y2Sym0) SY2-    instance SingI (TyCon1 Y2 :: (~>) (X a) (Y (a :: Type))) where-      sing = (singFun1 @(TyCon1 Y2)) SY2
+ tests/compile-and-dump/Singletons/T371.ghc88.template view
@@ -0,0 +1,247 @@+Singletons/T371.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Y (a :: Type)+            = Y1 | Y2 (X a)+            deriving Show+          data X (a :: Type)+            = X1 | X2 (Y a)+            deriving Show |]+  ======>+    data X (a :: Type)+      = X1 | X2 (Y a)+      deriving Show+    data Y (a :: Type)+      = Y1 | Y2 (X a)+      deriving Show+    type X1Sym0 = X1+    type X2Sym1 (t0123456789876543210 :: Y a0123456789876543210) =+        X2 t0123456789876543210+    instance SuppressUnusedWarnings X2Sym0 where+      suppressUnusedWarnings = snd (((,) X2Sym0KindInference) ())+    data X2Sym0 :: forall (a0123456789876543210 :: Type).+                   (~>) (Y a0123456789876543210) (X (a0123456789876543210 :: Type))+      where+        X2Sym0KindInference :: forall t0123456789876543210+                                      arg. SameKind (Apply X2Sym0 arg) (X2Sym1 arg) =>+                               X2Sym0 t0123456789876543210+    type instance Apply X2Sym0 t0123456789876543210 = X2 t0123456789876543210+    type Y1Sym0 = Y1+    type Y2Sym1 (t0123456789876543210 :: X a0123456789876543210) =+        Y2 t0123456789876543210+    instance SuppressUnusedWarnings Y2Sym0 where+      suppressUnusedWarnings = snd (((,) Y2Sym0KindInference) ())+    data Y2Sym0 :: forall (a0123456789876543210 :: Type).+                   (~>) (X a0123456789876543210) (Y (a0123456789876543210 :: Type))+      where+        Y2Sym0KindInference :: forall t0123456789876543210+                                      arg. SameKind (Apply Y2Sym0 arg) (Y2Sym1 arg) =>+                               Y2Sym0 t0123456789876543210+    type instance Apply Y2Sym0 t0123456789876543210 = Y2 t0123456789876543210+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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) (Data.Singletons.Prelude.Num.FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "X2 ")) (Apply (Apply ShowsPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210+    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: X a0123456789876543210) (a0123456789876543210 :: GHC.Types.Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: X a0123456789876543210) :: (~>) GHC.Types.Symbol GHC.Types.Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.+                                                                                      (~>) (X a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.+                                              (~>) GHC.Types.Nat ((~>) (X a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow (X a) where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    type family ShowsPrec_0123456789876543210 (a :: GHC.Types.Nat) (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) (Data.Singletons.Prelude.Num.FromInteger 10))) (Apply (Apply (.@#@$) (Apply ShowStringSym0 "Y2 ")) (Apply (Apply ShowsPrecSym0 (Data.Singletons.Prelude.Num.FromInteger 11)) arg_0123456789876543210))) a_0123456789876543210+    type ShowsPrec_0123456789876543210Sym3 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Y a0123456789876543210) (a0123456789876543210 :: GHC.Types.Symbol) =+        ShowsPrec_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (ShowsPrec_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym2KindInference) ())+    data ShowsPrec_0123456789876543210Sym2 (a0123456789876543210 :: GHC.Types.Nat) (a0123456789876543210 :: Y a0123456789876543210) :: (~>) GHC.Types.Symbol GHC.Types.Symbol+      where+        ShowsPrec_0123456789876543210Sym2KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym1 a0123456789876543210) where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym1KindInference) ())+    data ShowsPrec_0123456789876543210Sym1 (a0123456789876543210 :: GHC.Types.Nat) :: forall a0123456789876543210.+                                                                                      (~>) (Y a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol)+      where+        ShowsPrec_0123456789876543210Sym1KindInference :: forall a0123456789876543210+                                                                 a0123456789876543210+                                                                 arg. 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_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd (((,) ShowsPrec_0123456789876543210Sym0KindInference) ())+    data ShowsPrec_0123456789876543210Sym0 :: forall a0123456789876543210.+                                              (~>) GHC.Types.Nat ((~>) (Y a0123456789876543210) ((~>) GHC.Types.Symbol GHC.Types.Symbol))+      where+        ShowsPrec_0123456789876543210Sym0KindInference :: forall a0123456789876543210+                                                                 arg. SameKind (Apply ShowsPrec_0123456789876543210Sym0 arg) (ShowsPrec_0123456789876543210Sym1 arg) =>+                                                          ShowsPrec_0123456789876543210Sym0 a0123456789876543210+    type instance Apply ShowsPrec_0123456789876543210Sym0 a0123456789876543210 = ShowsPrec_0123456789876543210Sym1 a0123456789876543210+    instance PShow (Y a) where+      type ShowsPrec a a a = Apply (Apply (Apply ShowsPrec_0123456789876543210Sym0 a) a) a+    data SX :: forall a. X a -> Type+      where+        SX1 :: SX X1+        SX2 :: forall a (n :: Y a). (Sing (n :: Y a)) -> SX (X2 n)+    type instance Sing @(X a) = SX+    instance SingKind a => SingKind (X a) where+      type Demote (X a) = X (Demote a)+      fromSing SX1 = X1+      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) }+    data SY :: forall a. Y a -> Type+      where+        SY1 :: SY Y1+        SY2 :: forall a (n :: X a). (Sing (n :: X a)) -> SY (Y2 n)+    type instance Sing @(Y a) = SY+    instance SingKind a => SingKind (Y a) where+      type Demote (Y a) = Y (Demote a)+      fromSing SY1 = Y1+      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) }+    instance SShow (Y a) => SShow (X a) where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: X a) (t3 :: GHC.Types.Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (X a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))+                                                             -> Type) t1) t2) t3)+      sShowsPrec+        _+        SX1+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "X1")))+            sA_0123456789876543210+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SX2 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "X2 "))))+                   ((applySing+                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                          (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 11))))+                      sArg_0123456789876543210))))+            sA_0123456789876543210+    instance SShow (X a) => SShow (Y a) where+      sShowsPrec ::+        forall (t1 :: GHC.Types.Nat) (t2 :: Y a) (t3 :: GHC.Types.Symbol).+        Sing t1+        -> Sing t2+           -> Sing t3+              -> Sing (Apply (Apply (Apply (ShowsPrecSym0 :: TyFun GHC.Types.Nat ((~>) (Y a) ((~>) GHC.Types.Symbol GHC.Types.Symbol))+                                                             -> Type) t1) t2) t3)+      sShowsPrec+        _+        SY1+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing ((singFun2 @ShowStringSym0) sShowString))+                (sing :: Sing "Y1")))+            sA_0123456789876543210+      sShowsPrec+        (sP_0123456789876543210 :: Sing p_0123456789876543210)+        (SY2 (sArg_0123456789876543210 :: Sing arg_0123456789876543210))+        (sA_0123456789876543210 :: Sing a_0123456789876543210)+        = (applySing+             ((applySing+                 ((applySing ((singFun3 @ShowParenSym0) sShowParen))+                    ((applySing+                        ((applySing ((singFun2 @(>@#@$)) (%>))) sP_0123456789876543210))+                       (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 10)))))+                ((applySing+                    ((applySing ((singFun3 @(.@#@$)) (%.)))+                       ((applySing ((singFun2 @ShowStringSym0) sShowString))+                          (sing :: Sing "Y2 "))))+                   ((applySing+                       ((applySing ((singFun3 @ShowsPrecSym0) sShowsPrec))+                          (Data.Singletons.Prelude.Num.sFromInteger (sing :: Sing 11))))+                      sArg_0123456789876543210))))+            sA_0123456789876543210+    instance Data.Singletons.ShowSing.ShowSing (Y a) =>+             Show (SX (z :: X a)) where+      showsPrec _ SX1 = showString "SX1"+      showsPrec+        p_0123456789876543210+        (SX2 (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SX2 "))+               ((showsPrec 11) arg_0123456789876543210)) ::+            Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210 =>+            ShowS+    instance Data.Singletons.ShowSing.ShowSing (X a) =>+             Show (SY (z :: Y a)) where+      showsPrec _ SY1 = showString "SY1"+      showsPrec+        p_0123456789876543210+        (SY2 (arg_0123456789876543210 :: Sing argTy_0123456789876543210))+        = (showParen (((>) p_0123456789876543210) 10))+            (((.) (showString "SY2 "))+               ((showsPrec 11) arg_0123456789876543210)) ::+            Data.Singletons.ShowSing.ShowSing' argTy_0123456789876543210 =>+            ShowS+    instance SingI X1 where+      sing = SX1+    instance SingI n => SingI (X2 (n :: Y a)) where+      sing = SX2 sing+    instance SingI (X2Sym0 :: (~>) (Y a) (X (a :: Type))) where+      sing = (singFun1 @X2Sym0) SX2+    instance SingI Y1 where+      sing = SY1+    instance SingI n => SingI (Y2 (n :: X a)) where+      sing = SY2 sing+    instance SingI (Y2Sym0 :: (~>) (X a) (Y (a :: Type))) where+      sing = (singFun1 @Y2Sym0) SY2
+ tests/compile-and-dump/Singletons/T376.ghc88.template view
@@ -0,0 +1,40 @@+Singletons/T376.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| f :: (() -> ()) -> (() -> ())+          f g = g :: () -> () |]+  ======>+    f :: (() -> ()) -> () -> ()+    f g = g :: () -> ()+    type FSym2 (a0123456789876543210 :: (~>) () ()) (a0123456789876543210 :: ()) =+        F a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings (FSym1 a0123456789876543210) where+      suppressUnusedWarnings = snd (((,) FSym1KindInference) ())+    data FSym1 (a0123456789876543210 :: (~>) () ()) :: (~>) () ()+      where+        FSym1KindInference :: forall a0123456789876543210+                                     a0123456789876543210+                                     arg. SameKind (Apply (FSym1 a0123456789876543210) arg) (FSym2 a0123456789876543210 arg) =>+                              FSym1 a0123456789876543210 a0123456789876543210+    type instance Apply (FSym1 a0123456789876543210) a0123456789876543210 = F a0123456789876543210 a0123456789876543210+    instance SuppressUnusedWarnings FSym0 where+      suppressUnusedWarnings = snd (((,) FSym0KindInference) ())+    data FSym0 :: (~>) ((~>) () ()) ((~>) () ())+      where+        FSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>+                              FSym0 a0123456789876543210+    type instance Apply FSym0 a0123456789876543210 = FSym1 a0123456789876543210+    type family F (a :: (~>) () ()) (a :: ()) :: () where+      F g a_0123456789876543210 = Apply (g :: (~>) () ()) a_0123456789876543210+    sF ::+      forall (t :: (~>) () ()) (t :: ()).+      Sing t -> Sing t -> Sing (Apply (Apply FSym0 t) t :: ())+    sF+      (sG :: Sing g)+      (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing (sG :: Sing (g :: (~>) () ()))) sA_0123456789876543210+    instance SingI (FSym0 :: (~>) ((~>) () ()) ((~>) () ())) where+      sing = (singFun2 @FSym0) sF+    instance SingI d =>+             SingI (FSym1 (d :: (~>) () ()) :: (~>) () ()) where+      sing = (singFun1 @(FSym1 (d :: (~>) () ()))) (sF (sing @d))
+ tests/compile-and-dump/Singletons/T376.hs view
@@ -0,0 +1,8 @@+module T376 where++import Data.Singletons.TH++$(singletons [d|+  f :: (() -> ()) -> (() -> ())+  f g = g :: () -> ()+  |])
+ tests/compile-and-dump/Singletons/T402.ghc88.template view
@@ -0,0 +1,15 @@+Singletons/T402.hs:0:0:: Splicing declarations+    singletons [d| type AnyOfKind (k :: Type) = Any :: k |]+  ======>+    type AnyOfKind (k :: Type) = Any :: k+    type AnyOfKindSym1 (k0123456789876543210 :: Type) =+        AnyOfKind k0123456789876543210+    instance SuppressUnusedWarnings AnyOfKindSym0 where+      suppressUnusedWarnings = snd (((,) AnyOfKindSym0KindInference) ())+    data AnyOfKindSym0 :: forall (k0123456789876543210 :: Type).+                          (~>) Type k0123456789876543210+      where+        AnyOfKindSym0KindInference :: forall k0123456789876543210+                                             arg. SameKind (Apply AnyOfKindSym0 arg) (AnyOfKindSym1 arg) =>+                                      AnyOfKindSym0 k0123456789876543210+    type instance Apply AnyOfKindSym0 k0123456789876543210 = AnyOfKind k0123456789876543210
+ tests/compile-and-dump/Singletons/T402.hs view
@@ -0,0 +1,7 @@+module T402 where++import Data.Kind+import Data.Singletons.TH++type family Any :: k+$(singletons [d| type AnyOfKind (k :: Type) = Any :: k |])
− tests/compile-and-dump/Singletons/T54.ghc86.template 
@@ -1,53 +0,0 @@-Singletons/T54.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| g :: Bool -> Bool-          g e = (case [not] of { [_] -> not }) e |]-  ======>-    g :: Bool -> Bool-    g e = (case [not] of { [_] -> not }) e-    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 e0123456789876543210 =-        Let0123456789876543210Scrutinee_0123456789876543210 e0123456789876543210-    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where-      suppressUnusedWarnings-        = snd-            (((,)-                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)-               ())-    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210-      where-        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall e0123456789876543210-                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>-                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210-    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 e0123456789876543210-    type family Let0123456789876543210Scrutinee_0123456789876543210 e where-      Let0123456789876543210Scrutinee_0123456789876543210 e = Apply (Apply (:@#@$) NotSym0) '[]-    type family Case_0123456789876543210 e t where-      Case_0123456789876543210 e '[_] = NotSym0-    type GSym1 (a0123456789876543210 :: Bool) = G a0123456789876543210-    instance SuppressUnusedWarnings GSym0 where-      suppressUnusedWarnings = snd (((,) GSym0KindInference) ())-    data GSym0 :: (~>) Bool Bool-      where-        GSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply GSym0 arg) (GSym1 arg) =>-                              GSym0 a0123456789876543210-    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210-    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)-    sG (sE :: Sing e)-      = (applySing-           (let-              sScrutinee_0123456789876543210 ::-                Sing (Let0123456789876543210Scrutinee_0123456789876543210Sym1 e)-              sScrutinee_0123456789876543210-                = (applySing-                     ((applySing ((singFun2 @(:@#@$)) SCons))-                        ((singFun1 @NotSym0) sNot)))-                    SNil-            in  (case sScrutinee_0123456789876543210 of {-                   SCons _ SNil -> (singFun1 @NotSym0) sNot }) ::-                  Sing (Case_0123456789876543210 e (Let0123456789876543210Scrutinee_0123456789876543210Sym1 e))))-          sE-    instance SingI (GSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @GSym0) sG
+ tests/compile-and-dump/Singletons/T54.ghc88.template view
@@ -0,0 +1,55 @@+Singletons/T54.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| g :: Bool -> Bool+          g e = (case [not] of { [_] -> not }) e |]+  ======>+    g :: Bool -> Bool+    g e = (case [not] of { [_] -> not }) e+    type Let0123456789876543210Scrutinee_0123456789876543210Sym1 e0123456789876543210 =+        Let0123456789876543210Scrutinee_0123456789876543210 e0123456789876543210+    instance SuppressUnusedWarnings Let0123456789876543210Scrutinee_0123456789876543210Sym0 where+      suppressUnusedWarnings+        = snd+            (((,)+                Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference)+               ())+    data Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210+      where+        Let0123456789876543210Scrutinee_0123456789876543210Sym0KindInference :: forall e0123456789876543210+                                                                                       arg. SameKind (Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 arg) (Let0123456789876543210Scrutinee_0123456789876543210Sym1 arg) =>+                                                                                Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210+    type instance Apply Let0123456789876543210Scrutinee_0123456789876543210Sym0 e0123456789876543210 = Let0123456789876543210Scrutinee_0123456789876543210 e0123456789876543210+    type family Let0123456789876543210Scrutinee_0123456789876543210 e where+      Let0123456789876543210Scrutinee_0123456789876543210 e = Apply (Apply (:@#@$) NotSym0) '[]+    type family Case_0123456789876543210 e t where+      Case_0123456789876543210 e '[_] = NotSym0+    type GSym1 (a0123456789876543210 :: Bool) = G a0123456789876543210+    instance SuppressUnusedWarnings GSym0 where+      suppressUnusedWarnings = snd (((,) GSym0KindInference) ())+    data GSym0 :: (~>) Bool Bool+      where+        GSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply GSym0 arg) (GSym1 arg) =>+                              GSym0 a0123456789876543210+    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210+    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)+    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 })))+          sE+    instance SingI (GSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @GSym0) sG
− tests/compile-and-dump/Singletons/T78.ghc86.template 
@@ -1,32 +0,0 @@-Singletons/T78.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo :: MaybeBool -> Bool-          foo (Just False) = False-          foo (Just True) = True-          foo Nothing = False |]-  ======>-    foo :: MaybeBool -> Bool-    foo (Just False) = False-    foo (Just True) = True-    foo Nothing = False-    type FooSym1 (a0123456789876543210 :: Maybe Bool) =-        Foo a0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: (~>) (Maybe Bool) Bool-      where-        FooSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210-    type family Foo (a :: Maybe Bool) :: Bool where-      Foo ( 'Just  'False) = FalseSym0-      Foo ( 'Just  'True) = TrueSym0-      Foo  'Nothing = FalseSym0-    sFoo ::-      forall (t :: Maybe Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)-    sFoo (SJust SFalse) = SFalse-    sFoo (SJust STrue) = STrue-    sFoo SNothing = SFalse-    instance SingI (FooSym0 :: (~>) (Maybe Bool) Bool) where-      sing = (singFun1 @FooSym0) sFoo
+ tests/compile-and-dump/Singletons/T78.ghc88.template view
@@ -0,0 +1,32 @@+Singletons/T78.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo :: MaybeBool -> Bool+          foo (Just False) = False+          foo (Just True) = True+          foo Nothing = False |]+  ======>+    foo :: MaybeBool -> Bool+    foo (Just False) = False+    foo (Just True) = True+    foo Nothing = False+    type FooSym1 (a0123456789876543210 :: Maybe Bool) =+        Foo a0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: (~>) (Maybe Bool) Bool+      where+        FooSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 a0123456789876543210+    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210+    type family Foo (a :: Maybe Bool) :: Bool where+      Foo ('Just 'False) = FalseSym0+      Foo ('Just 'True) = TrueSym0+      Foo 'Nothing = FalseSym0+    sFoo ::+      forall (t :: Maybe Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)+    sFoo (SJust SFalse) = SFalse+    sFoo (SJust STrue) = STrue+    sFoo SNothing = SFalse+    instance SingI (FooSym0 :: (~>) (Maybe Bool) Bool) where+      sing = (singFun1 @FooSym0) sFoo
− tests/compile-and-dump/Singletons/TopLevelPatterns.ghc86.template 
@@ -1,347 +0,0 @@-Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| data Bool = False | True-          data Foo = Bar Bool Bool |]-  ======>-    data Bool = False | True-    data Foo = Bar Bool Bool-    type FalseSym0 = False-    type TrueSym0 = True-    type BarSym2 (t0123456789876543210 :: Bool) (t0123456789876543210 :: Bool) =-        Bar t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings (BarSym1 t0123456789876543210) where-      suppressUnusedWarnings-        = Data.Tuple.snd (((,) BarSym1KindInference) ())-    data BarSym1 (t0123456789876543210 :: Bool) :: (~>) Bool Foo-      where-        BarSym1KindInference :: forall t0123456789876543210-                                       t0123456789876543210-                                       arg. SameKind (Apply (BarSym1 t0123456789876543210) arg) (BarSym2 t0123456789876543210 arg) =>-                                BarSym1 t0123456789876543210 t0123456789876543210-    type instance Apply (BarSym1 t0123456789876543210) t0123456789876543210 = Bar t0123456789876543210 t0123456789876543210-    instance SuppressUnusedWarnings BarSym0 where-      suppressUnusedWarnings-        = Data.Tuple.snd (((,) BarSym0KindInference) ())-    data BarSym0 :: (~>) Bool ((~>) Bool Foo)-      where-        BarSym0KindInference :: forall t0123456789876543210-                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>-                                BarSym0 t0123456789876543210-    type instance Apply BarSym0 t0123456789876543210 = BarSym1 t0123456789876543210-    data instance Sing :: Bool -> GHC.Types.Type-      where-        SFalse :: Sing False-        STrue :: Sing True-    type SBool = (Sing :: Bool -> GHC.Types.Type)-    instance SingKind Bool where-      type Demote Bool = Bool-      fromSing SFalse = False-      fromSing STrue = True-      toSing False = SomeSing SFalse-      toSing True = SomeSing STrue-    data instance Sing :: Foo -> GHC.Types.Type-      where-        SBar :: forall (n :: Bool) (n :: Bool).-                (Sing (n :: Bool)) -> (Sing (n :: Bool)) -> Sing (Bar n n)-    type SFoo = (Sing :: Foo -> GHC.Types.Type)-    instance SingKind Foo where-      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) }-    instance SingI False where-      sing = SFalse-    instance SingI True where-      sing = STrue-    instance (SingI n, SingI n) =>-             SingI (Bar (n :: Bool) (n :: Bool)) where-      sing = (SBar sing) sing-    instance SingI (BarSym0 :: (~>) Bool ((~>) Bool Foo)) where-      sing = (singFun2 @BarSym0) SBar-    instance SingI (TyCon2 Bar :: (~>) Bool ((~>) Bool Foo)) where-      sing = (singFun2 @(TyCon2 Bar)) SBar-    instance SingI d =>-             SingI (BarSym1 (d :: Bool) :: (~>) Bool Foo) where-      sing = (singFun1 @(BarSym1 (d :: Bool))) (SBar (sing @d))-    instance SingI d =>-             SingI (TyCon1 (Bar (d :: Bool)) :: (~>) Bool Foo) where-      sing = (singFun1 @(TyCon1 (Bar (d :: Bool)))) (SBar (sing @d))-Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| otherwise :: Bool-          otherwise = True-          id :: a -> a-          id x = x-          not :: Bool -> Bool-          not True = False-          not False = True-          false_ = False-          f, g :: Bool -> Bool-          [f, g] = [not, id]-          h, i :: Bool -> Bool-          (h, i) = (f, g)-          j, k :: Bool-          (Bar j k) = Bar True (h False)-          l, m :: Bool-          [l, m] = [not True, id False] |]-  ======>-    otherwise :: Bool-    otherwise = True-    id :: a -> a-    id x = x-    not :: Bool -> Bool-    not True = False-    not False = True-    false_ = False-    f :: Bool -> Bool-    g :: Bool -> Bool-    [f, g] = [not, id]-    h :: Bool -> Bool-    i :: Bool -> Bool-    (h, i) = (f, g)-    j :: Bool-    k :: Bool-    Bar j k = (Bar True) (h False)-    l :: Bool-    m :: Bool-    [l, m] = [not True, id False]-    type family Case_0123456789876543210 a_0123456789876543210 t where-      Case_0123456789876543210 a_0123456789876543210 '[y_0123456789876543210,-                                                       _] = y_0123456789876543210-    type family Case_0123456789876543210 a_0123456789876543210 t where-      Case_0123456789876543210 a_0123456789876543210 '[_,-                                                       y_0123456789876543210] = y_0123456789876543210-    type family Case_0123456789876543210 a_0123456789876543210 t where-      Case_0123456789876543210 a_0123456789876543210 '(y_0123456789876543210,-                                                       _) = y_0123456789876543210-    type family Case_0123456789876543210 a_0123456789876543210 t where-      Case_0123456789876543210 a_0123456789876543210 '(_,-                                                       y_0123456789876543210) = y_0123456789876543210-    type family 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 t where-      Case_0123456789876543210 '[y_0123456789876543210,-                                 _] = y_0123456789876543210-    type family Case_0123456789876543210 t where-      Case_0123456789876543210 '[_,-                                 y_0123456789876543210] = y_0123456789876543210-    type False_Sym0 = False_-    type NotSym1 (a0123456789876543210 :: Bool) =-        Not a0123456789876543210-    instance SuppressUnusedWarnings NotSym0 where-      suppressUnusedWarnings-        = Data.Tuple.snd (((,) NotSym0KindInference) ())-    data NotSym0 :: (~>) Bool Bool-      where-        NotSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply NotSym0 arg) (NotSym1 arg) =>-                                NotSym0 a0123456789876543210-    type instance Apply NotSym0 a0123456789876543210 = Not a0123456789876543210-    type IdSym1 (a0123456789876543210 :: a0123456789876543210) =-        Id a0123456789876543210-    instance SuppressUnusedWarnings IdSym0 where-      suppressUnusedWarnings-        = Data.Tuple.snd (((,) IdSym0KindInference) ())-    data IdSym0 :: forall a0123456789876543210.-                   (~>) a0123456789876543210 a0123456789876543210-      where-        IdSym0KindInference :: forall a0123456789876543210-                                      arg. SameKind (Apply IdSym0 arg) (IdSym1 arg) =>-                               IdSym0 a0123456789876543210-    type instance Apply IdSym0 a0123456789876543210 = Id a0123456789876543210-    type FSym1 (a0123456789876543210 :: Bool) = F a0123456789876543210-    instance SuppressUnusedWarnings FSym0 where-      suppressUnusedWarnings-        = Data.Tuple.snd (((,) FSym0KindInference) ())-    data FSym0 :: (~>) Bool Bool-      where-        FSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>-                              FSym0 a0123456789876543210-    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210-    type GSym1 (a0123456789876543210 :: Bool) = G a0123456789876543210-    instance SuppressUnusedWarnings GSym0 where-      suppressUnusedWarnings-        = Data.Tuple.snd (((,) GSym0KindInference) ())-    data GSym0 :: (~>) Bool Bool-      where-        GSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply GSym0 arg) (GSym1 arg) =>-                              GSym0 a0123456789876543210-    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210-    type HSym1 (a0123456789876543210 :: Bool) = H a0123456789876543210-    instance SuppressUnusedWarnings HSym0 where-      suppressUnusedWarnings-        = Data.Tuple.snd (((,) HSym0KindInference) ())-    data HSym0 :: (~>) Bool Bool-      where-        HSym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply HSym0 arg) (HSym1 arg) =>-                              HSym0 a0123456789876543210-    type instance Apply HSym0 a0123456789876543210 = H a0123456789876543210-    type ISym1 (a0123456789876543210 :: Bool) = I a0123456789876543210-    instance SuppressUnusedWarnings ISym0 where-      suppressUnusedWarnings-        = Data.Tuple.snd (((,) ISym0KindInference) ())-    data ISym0 :: (~>) Bool Bool-      where-        ISym0KindInference :: forall a0123456789876543210-                                     arg. SameKind (Apply ISym0 arg) (ISym1 arg) =>-                              ISym0 a0123456789876543210-    type instance Apply ISym0 a0123456789876543210 = I a0123456789876543210-    type JSym0 = J-    type KSym0 = K-    type LSym0 = L-    type MSym0 = M-    type OtherwiseSym0 = Otherwise-    type X_0123456789876543210Sym0 = X_0123456789876543210-    type X_0123456789876543210Sym0 = X_0123456789876543210-    type X_0123456789876543210Sym0 = X_0123456789876543210-    type X_0123456789876543210Sym0 = X_0123456789876543210-    type family False_ where-      False_ = FalseSym0-    type family Not (a :: Bool) :: Bool where-      Not  'True = FalseSym0-      Not  'False = TrueSym0-    type family Id (a :: a) :: a where-      Id x = x-    type family F (a :: Bool) :: Bool where-      F a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210-    type family G (a :: Bool) :: Bool where-      G a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210-    type family H (a :: Bool) :: Bool where-      H a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210-    type family I (a :: Bool) :: Bool where-      I a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210-    type family J :: Bool where-      J = Case_0123456789876543210 X_0123456789876543210Sym0-    type family K :: Bool where-      K = Case_0123456789876543210 X_0123456789876543210Sym0-    type family L :: Bool where-      L = Case_0123456789876543210 X_0123456789876543210Sym0-    type family M :: Bool where-      M = Case_0123456789876543210 X_0123456789876543210Sym0-    type family Otherwise :: Bool where-      Otherwise = TrueSym0-    type family X_0123456789876543210 where-      X_0123456789876543210 = Apply (Apply (:@#@$) NotSym0) (Apply (Apply (:@#@$) IdSym0) '[])-    type family X_0123456789876543210 where-      X_0123456789876543210 = Apply (Apply Tuple2Sym0 FSym0) GSym0-    type family X_0123456789876543210 where-      X_0123456789876543210 = Apply (Apply BarSym0 TrueSym0) (Apply HSym0 FalseSym0)-    type family X_0123456789876543210 where-      X_0123456789876543210 = Apply (Apply (:@#@$) (Apply NotSym0 TrueSym0)) (Apply (Apply (:@#@$) (Apply IdSym0 FalseSym0)) '[])-    sFalse_ :: Sing False_Sym0-    sNot ::-      forall (t :: Bool). Sing t -> Sing (Apply NotSym0 t :: Bool)-    sId :: forall a (t :: a). Sing t -> Sing (Apply IdSym0 t :: a)-    sF :: forall (t :: Bool). Sing t -> Sing (Apply FSym0 t :: Bool)-    sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool)-    sH :: forall (t :: Bool). Sing t -> Sing (Apply HSym0 t :: Bool)-    sI :: forall (t :: Bool). Sing t -> Sing (Apply ISym0 t :: Bool)-    sJ :: Sing (JSym0 :: Bool)-    sK :: Sing (KSym0 :: Bool)-    sL :: Sing (LSym0 :: Bool)-    sM :: Sing (MSym0 :: Bool)-    sOtherwise :: Sing (OtherwiseSym0 :: Bool)-    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0-    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0-    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0-    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0-    sFalse_ = SFalse-    sNot STrue = SFalse-    sNot SFalse = STrue-    sId (sX :: Sing x) = sX-    sF (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((case sX_0123456789876543210 of {-               SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)-                     (SCons _ SNil)-                 -> sY_0123456789876543210 }) ::-              Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))-          sA_0123456789876543210-    sG (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((case sX_0123456789876543210 of {-               SCons _-                     (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil)-                 -> sY_0123456789876543210 }) ::-              Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))-          sA_0123456789876543210-    sH (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((case sX_0123456789876543210 of {-               STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _-                 -> sY_0123456789876543210 }) ::-              Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))-          sA_0123456789876543210-    sI (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (applySing-           ((case sX_0123456789876543210 of {-               STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210)-                 -> sY_0123456789876543210 }) ::-              Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))-          sA_0123456789876543210-    sJ-      = (case sX_0123456789876543210 of {-           SBar (sY_0123456789876543210 :: Sing y_0123456789876543210) _-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)-    sK-      = (case sX_0123456789876543210 of {-           SBar _ (sY_0123456789876543210 :: Sing y_0123456789876543210)-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)-    sL-      = (case sX_0123456789876543210 of {-           SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)-                 (SCons _ SNil)-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)-    sM-      = (case sX_0123456789876543210 of {-           SCons _-                 (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil)-             -> sY_0123456789876543210 }) ::-          Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)-    sOtherwise = STrue-    sX_0123456789876543210-      = (applySing-           ((applySing ((singFun2 @(:@#@$)) SCons))-              ((singFun1 @NotSym0) sNot)))-          ((applySing-              ((applySing ((singFun2 @(:@#@$)) SCons)) ((singFun1 @IdSym0) sId)))-             SNil)-    sX_0123456789876543210-      = (applySing-           ((applySing ((singFun2 @Tuple2Sym0) STuple2))-              ((singFun1 @FSym0) sF)))-          ((singFun1 @GSym0) sG)-    sX_0123456789876543210-      = (applySing ((applySing ((singFun2 @BarSym0) SBar)) STrue))-          ((applySing ((singFun1 @HSym0) sH)) SFalse)-    sX_0123456789876543210-      = (applySing-           ((applySing ((singFun2 @(:@#@$)) SCons))-              ((applySing ((singFun1 @NotSym0) sNot)) STrue)))-          ((applySing-              ((applySing ((singFun2 @(:@#@$)) SCons))-                 ((applySing ((singFun1 @IdSym0) sId)) SFalse)))-             SNil)-    instance SingI (NotSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @NotSym0) sNot-    instance SingI (IdSym0 :: (~>) a a) where-      sing = (singFun1 @IdSym0) sId-    instance SingI (FSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @FSym0) sF-    instance SingI (GSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @GSym0) sG-    instance SingI (HSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @HSym0) sH-    instance SingI (ISym0 :: (~>) Bool Bool) where-      sing = (singFun1 @ISym0) sI
+ tests/compile-and-dump/Singletons/TopLevelPatterns.ghc88.template view
@@ -0,0 +1,350 @@+Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| data Bool = False | True+          data Foo = Bar Bool Bool |]+  ======>+    data Bool = False | True+    data Foo = Bar Bool Bool+    type FalseSym0 = False+    type TrueSym0 = True+    type BarSym2 (t0123456789876543210 :: Bool) (t0123456789876543210 :: Bool) =+        Bar t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings (BarSym1 t0123456789876543210) where+      suppressUnusedWarnings+        = Data.Tuple.snd (((,) BarSym1KindInference) ())+    data BarSym1 (t0123456789876543210 :: Bool) :: (~>) Bool Foo+      where+        BarSym1KindInference :: forall t0123456789876543210+                                       t0123456789876543210+                                       arg. SameKind (Apply (BarSym1 t0123456789876543210) arg) (BarSym2 t0123456789876543210 arg) =>+                                BarSym1 t0123456789876543210 t0123456789876543210+    type instance Apply (BarSym1 t0123456789876543210) t0123456789876543210 = Bar t0123456789876543210 t0123456789876543210+    instance SuppressUnusedWarnings BarSym0 where+      suppressUnusedWarnings+        = Data.Tuple.snd (((,) BarSym0KindInference) ())+    data BarSym0 :: (~>) Bool ((~>) Bool Foo)+      where+        BarSym0KindInference :: forall t0123456789876543210+                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>+                                BarSym0 t0123456789876543210+    type instance Apply BarSym0 t0123456789876543210 = BarSym1 t0123456789876543210+    data SBool :: Bool -> GHC.Types.Type+      where+        SFalse :: SBool False+        STrue :: SBool True+    type instance Sing @Bool = SBool+    instance SingKind Bool where+      type Demote Bool = Bool+      fromSing SFalse = False+      fromSing STrue = True+      toSing False = SomeSing SFalse+      toSing True = SomeSing STrue+    data SFoo :: Foo -> GHC.Types.Type+      where+        SBar :: forall (n :: Bool) (n :: Bool).+                (Sing (n :: Bool)) -> (Sing (n :: Bool)) -> SFoo (Bar n n)+    type instance Sing @Foo = SFoo+    instance SingKind Foo where+      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) }+    instance SingI False where+      sing = SFalse+    instance SingI True where+      sing = STrue+    instance (SingI n, SingI n) =>+             SingI (Bar (n :: Bool) (n :: Bool)) where+      sing = (SBar sing) sing+    instance SingI (BarSym0 :: (~>) Bool ((~>) Bool Foo)) where+      sing = (singFun2 @BarSym0) SBar+    instance SingI d =>+             SingI (BarSym1 (d :: Bool) :: (~>) Bool Foo) where+      sing = (singFun1 @(BarSym1 (d :: Bool))) (SBar (sing @d))+Singletons/TopLevelPatterns.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| otherwise :: Bool+          otherwise = True+          id :: a -> a+          id x = x+          not :: Bool -> Bool+          not True = False+          not False = True+          false_ = False+          f, g :: Bool -> Bool+          [f, g] = [not, id]+          h, i :: Bool -> Bool+          (h, i) = (f, g)+          j, k :: Bool+          (Bar j k) = Bar True (h False)+          l, m :: Bool+          [l, m] = [not True, id False] |]+  ======>+    otherwise :: Bool+    otherwise = True+    id :: a -> a+    id x = x+    not :: Bool -> Bool+    not True = False+    not False = True+    false_ = False+    f :: Bool -> Bool+    g :: Bool -> Bool+    [f, g] = [not, id]+    h :: Bool -> Bool+    i :: Bool -> Bool+    (h, i) = (f, g)+    j :: Bool+    k :: Bool+    Bar j k = (Bar True) (h False)+    l :: Bool+    m :: Bool+    [l, m] = [not True, id False]+    type family Case_0123456789876543210 t where+      Case_0123456789876543210 '[_,+                                 y_0123456789876543210] = y_0123456789876543210+    type family Case_0123456789876543210 t where+      Case_0123456789876543210 '[y_0123456789876543210,+                                 _] = y_0123456789876543210+    type family Case_0123456789876543210 t where+      Case_0123456789876543210 ('Bar _ y_0123456789876543210) = y_0123456789876543210+    type family Case_0123456789876543210 t where+      Case_0123456789876543210 ('Bar y_0123456789876543210 _) = y_0123456789876543210+    type family Case_0123456789876543210 a_0123456789876543210 t where+      Case_0123456789876543210 a_0123456789876543210 '(_,+                                                       y_0123456789876543210) = y_0123456789876543210+    type family Case_0123456789876543210 a_0123456789876543210 t where+      Case_0123456789876543210 a_0123456789876543210 '(y_0123456789876543210,+                                                       _) = y_0123456789876543210+    type family Case_0123456789876543210 a_0123456789876543210 t where+      Case_0123456789876543210 a_0123456789876543210 '[_,+                                                       y_0123456789876543210] = y_0123456789876543210+    type family Case_0123456789876543210 a_0123456789876543210 t where+      Case_0123456789876543210 a_0123456789876543210 '[y_0123456789876543210,+                                                       _] = y_0123456789876543210+    type MSym0 = M+    type LSym0 = L+    type X_0123456789876543210Sym0 = X_0123456789876543210+    type KSym0 = K+    type JSym0 = J+    type X_0123456789876543210Sym0 = X_0123456789876543210+    type ISym1 (a0123456789876543210 :: Bool) = I a0123456789876543210+    instance SuppressUnusedWarnings ISym0 where+      suppressUnusedWarnings+        = Data.Tuple.snd (((,) ISym0KindInference) ())+    data ISym0 :: (~>) Bool Bool+      where+        ISym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply ISym0 arg) (ISym1 arg) =>+                              ISym0 a0123456789876543210+    type instance Apply ISym0 a0123456789876543210 = I a0123456789876543210+    type HSym1 (a0123456789876543210 :: Bool) = H a0123456789876543210+    instance SuppressUnusedWarnings HSym0 where+      suppressUnusedWarnings+        = Data.Tuple.snd (((,) HSym0KindInference) ())+    data HSym0 :: (~>) Bool Bool+      where+        HSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply HSym0 arg) (HSym1 arg) =>+                              HSym0 a0123456789876543210+    type instance Apply HSym0 a0123456789876543210 = H a0123456789876543210+    type X_0123456789876543210Sym0 = X_0123456789876543210+    type GSym1 (a0123456789876543210 :: Bool) = G a0123456789876543210+    instance SuppressUnusedWarnings GSym0 where+      suppressUnusedWarnings+        = Data.Tuple.snd (((,) GSym0KindInference) ())+    data GSym0 :: (~>) Bool Bool+      where+        GSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply GSym0 arg) (GSym1 arg) =>+                              GSym0 a0123456789876543210+    type instance Apply GSym0 a0123456789876543210 = G a0123456789876543210+    type FSym1 (a0123456789876543210 :: Bool) = F a0123456789876543210+    instance SuppressUnusedWarnings FSym0 where+      suppressUnusedWarnings+        = Data.Tuple.snd (((,) FSym0KindInference) ())+    data FSym0 :: (~>) Bool Bool+      where+        FSym0KindInference :: forall a0123456789876543210+                                     arg. SameKind (Apply FSym0 arg) (FSym1 arg) =>+                              FSym0 a0123456789876543210+    type instance Apply FSym0 a0123456789876543210 = F a0123456789876543210+    type X_0123456789876543210Sym0 = X_0123456789876543210+    type False_Sym0 = False_+    type NotSym1 (a0123456789876543210 :: Bool) =+        Not a0123456789876543210+    instance SuppressUnusedWarnings NotSym0 where+      suppressUnusedWarnings+        = Data.Tuple.snd (((,) NotSym0KindInference) ())+    data NotSym0 :: (~>) Bool Bool+      where+        NotSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply NotSym0 arg) (NotSym1 arg) =>+                                NotSym0 a0123456789876543210+    type instance Apply NotSym0 a0123456789876543210 = Not a0123456789876543210+    type IdSym1 (a0123456789876543210 :: a0123456789876543210) =+        Id a0123456789876543210+    instance SuppressUnusedWarnings IdSym0 where+      suppressUnusedWarnings+        = Data.Tuple.snd (((,) IdSym0KindInference) ())+    data IdSym0 :: forall a0123456789876543210.+                   (~>) a0123456789876543210 a0123456789876543210+      where+        IdSym0KindInference :: forall a0123456789876543210+                                      arg. SameKind (Apply IdSym0 arg) (IdSym1 arg) =>+                               IdSym0 a0123456789876543210+    type instance Apply IdSym0 a0123456789876543210 = Id a0123456789876543210+    type OtherwiseSym0 = Otherwise+    type family M :: Bool where+      M = Case_0123456789876543210 X_0123456789876543210Sym0+    type family L :: Bool where+      L = Case_0123456789876543210 X_0123456789876543210Sym0+    type family X_0123456789876543210 where+      X_0123456789876543210 = Apply (Apply (:@#@$) (Apply NotSym0 TrueSym0)) (Apply (Apply (:@#@$) (Apply IdSym0 FalseSym0)) '[])+    type family K :: Bool where+      K = Case_0123456789876543210 X_0123456789876543210Sym0+    type family J :: Bool where+      J = Case_0123456789876543210 X_0123456789876543210Sym0+    type family X_0123456789876543210 where+      X_0123456789876543210 = Apply (Apply BarSym0 TrueSym0) (Apply HSym0 FalseSym0)+    type family I (a :: Bool) :: Bool where+      I a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210+    type family H (a :: Bool) :: Bool where+      H a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210+    type family X_0123456789876543210 where+      X_0123456789876543210 = Apply (Apply Tuple2Sym0 FSym0) GSym0+    type family G (a :: Bool) :: Bool where+      G a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210+    type family F (a :: Bool) :: Bool where+      F a_0123456789876543210 = Apply (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0) a_0123456789876543210+    type family X_0123456789876543210 where+      X_0123456789876543210 = Apply (Apply (:@#@$) NotSym0) (Apply (Apply (:@#@$) IdSym0) '[])+    type family False_ where+      False_ = FalseSym0+    type family Not (a :: Bool) :: Bool where+      Not 'True = FalseSym0+      Not 'False = TrueSym0+    type family Id (a :: a) :: a where+      Id x = x+    type family Otherwise :: Bool where+      Otherwise = TrueSym0+    sM :: Sing (MSym0 :: Bool)+    sL :: Sing (LSym0 :: Bool)+    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0+    sK :: Sing (KSym0 :: Bool)+    sJ :: Sing (JSym0 :: Bool)+    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0+    sI :: forall (t :: Bool). Sing t -> Sing (Apply ISym0 t :: Bool)+    sH :: forall (t :: Bool). Sing t -> Sing (Apply HSym0 t :: Bool)+    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0+    sG :: forall (t :: Bool). Sing t -> Sing (Apply GSym0 t :: Bool)+    sF :: forall (t :: Bool). Sing t -> Sing (Apply FSym0 t :: Bool)+    sX_0123456789876543210 :: Sing X_0123456789876543210Sym0+    sFalse_ :: Sing False_Sym0+    sNot ::+      forall (t :: Bool). Sing t -> Sing (Apply NotSym0 t :: Bool)+    sId :: forall a (t :: a). Sing t -> Sing (Apply IdSym0 t :: a)+    sOtherwise :: Sing (OtherwiseSym0 :: Bool)+    sM+      = (GHC.Base.id+           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))+          (case sX_0123456789876543210 of {+             SCons _+                   (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil)+               -> sY_0123456789876543210 })+    sL+      = (GHC.Base.id+           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))+          (case sX_0123456789876543210 of {+             SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)+                   (SCons _ SNil)+               -> sY_0123456789876543210 })+    sX_0123456789876543210+      = (applySing+           ((applySing ((singFun2 @(:@#@$)) SCons))+              ((applySing ((singFun1 @NotSym0) sNot)) STrue)))+          ((applySing+              ((applySing ((singFun2 @(:@#@$)) SCons))+                 ((applySing ((singFun1 @IdSym0) sId)) SFalse)))+             SNil)+    sK+      = (GHC.Base.id+           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))+          (case sX_0123456789876543210 of {+             SBar _ (sY_0123456789876543210 :: Sing y_0123456789876543210)+               -> sY_0123456789876543210 })+    sJ+      = (GHC.Base.id+           @(Sing (Case_0123456789876543210 X_0123456789876543210Sym0 :: Bool)))+          (case sX_0123456789876543210 of {+             SBar (sY_0123456789876543210 :: Sing y_0123456789876543210) _+               -> sY_0123456789876543210 })+    sX_0123456789876543210+      = (applySing ((applySing ((singFun2 @BarSym0) SBar)) STrue))+          ((applySing ((singFun1 @HSym0) sH)) SFalse)+    sI (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing+           ((GHC.Base.id+               @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))+              (case sX_0123456789876543210 of {+                 STuple2 _ (sY_0123456789876543210 :: Sing y_0123456789876543210)+                   -> sY_0123456789876543210 })))+          sA_0123456789876543210+    sH (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing+           ((GHC.Base.id+               @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))+              (case sX_0123456789876543210 of {+                 STuple2 (sY_0123456789876543210 :: Sing y_0123456789876543210) _+                   -> sY_0123456789876543210 })))+          sA_0123456789876543210+    sX_0123456789876543210+      = (applySing+           ((applySing ((singFun2 @Tuple2Sym0) STuple2))+              ((singFun1 @FSym0) sF)))+          ((singFun1 @GSym0) sG)+    sG (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing+           ((GHC.Base.id+               @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))+              (case sX_0123456789876543210 of {+                 SCons _+                       (SCons (sY_0123456789876543210 :: Sing y_0123456789876543210) SNil)+                   -> sY_0123456789876543210 })))+          sA_0123456789876543210+    sF (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (applySing+           ((GHC.Base.id+               @(Sing (Case_0123456789876543210 a_0123456789876543210 X_0123456789876543210Sym0)))+              (case sX_0123456789876543210 of {+                 SCons (sY_0123456789876543210 :: Sing y_0123456789876543210)+                       (SCons _ SNil)+                   -> sY_0123456789876543210 })))+          sA_0123456789876543210+    sX_0123456789876543210+      = (applySing+           ((applySing ((singFun2 @(:@#@$)) SCons))+              ((singFun1 @NotSym0) sNot)))+          ((applySing+              ((applySing ((singFun2 @(:@#@$)) SCons)) ((singFun1 @IdSym0) sId)))+             SNil)+    sFalse_ = SFalse+    sNot STrue = SFalse+    sNot SFalse = STrue+    sId (sX :: Sing x) = sX+    sOtherwise = STrue+    instance SingI (ISym0 :: (~>) Bool Bool) where+      sing = (singFun1 @ISym0) sI+    instance SingI (HSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @HSym0) sH+    instance SingI (GSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @GSym0) sG+    instance SingI (FSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @FSym0) sF+    instance SingI (NotSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @NotSym0) sNot+    instance SingI (IdSym0 :: (~>) a a) where+      sing = (singFun1 @IdSym0) sId
tests/compile-and-dump/Singletons/TopLevelPatterns.hs view
@@ -6,7 +6,7 @@ import Data.Singletons import Data.Singletons.Prelude.List import Data.Singletons.SuppressUnusedWarnings-import Data.Singletons.TH hiding (STrue, SFalse, TrueSym0, FalseSym0)+import Data.Singletons.TH hiding (SBool(..), TrueSym0, FalseSym0)  $(singletons [d|   data Bool = False | True
− tests/compile-and-dump/Singletons/TypeRepTYPE.ghc86.template 
+ tests/compile-and-dump/Singletons/TypeRepTYPE.ghc88.template view
tests/compile-and-dump/Singletons/TypeRepTYPE.hs view
@@ -37,4 +37,4 @@   = NothingWordRep  h :: forall (rep :: RuntimeRep) (a :: TYPE rep). Typeable a => Sing a-h = STypeRep (typeRep @a)+h = typeRep @a
− tests/compile-and-dump/Singletons/Undef.ghc86.template 
@@ -1,47 +0,0 @@-Singletons/Undef.hs:(0,0)-(0,0): Splicing declarations-    singletons-      [d| foo :: Bool -> Bool-          foo = undefined-          bar :: Bool -> Bool-          bar = error "urk" |]-  ======>-    foo :: Bool -> Bool-    foo = undefined-    bar :: Bool -> Bool-    bar = error "urk"-    type BarSym1 (a0123456789876543210 :: Bool) =-        Bar a0123456789876543210-    instance SuppressUnusedWarnings BarSym0 where-      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())-    data BarSym0 :: (~>) Bool Bool-      where-        BarSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>-                                BarSym0 a0123456789876543210-    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210-    type FooSym1 (a0123456789876543210 :: Bool) =-        Foo a0123456789876543210-    instance SuppressUnusedWarnings FooSym0 where-      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())-    data FooSym0 :: (~>) Bool Bool-      where-        FooSym0KindInference :: forall a0123456789876543210-                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>-                                FooSym0 a0123456789876543210-    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210-    type family Bar (a :: Bool) :: Bool where-      Bar a_0123456789876543210 = Apply (Apply ErrorSym0 "urk") a_0123456789876543210-    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)-    sFoo ::-      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)-    sBar (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = (sError (sing :: Sing "urk")) sA_0123456789876543210-    sFoo (sA_0123456789876543210 :: Sing a_0123456789876543210)-      = sUndefined sA_0123456789876543210-    instance SingI (BarSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @BarSym0) sBar-    instance SingI (FooSym0 :: (~>) Bool Bool) where-      sing = (singFun1 @FooSym0) sFoo
+ tests/compile-and-dump/Singletons/Undef.ghc88.template view
@@ -0,0 +1,47 @@+Singletons/Undef.hs:(0,0)-(0,0): Splicing declarations+    singletons+      [d| foo :: Bool -> Bool+          foo = undefined+          bar :: Bool -> Bool+          bar = error "urk" |]+  ======>+    foo :: Bool -> Bool+    foo = undefined+    bar :: Bool -> Bool+    bar = error "urk"+    type BarSym1 (a0123456789876543210 :: Bool) =+        Bar a0123456789876543210+    instance SuppressUnusedWarnings BarSym0 where+      suppressUnusedWarnings = snd (((,) BarSym0KindInference) ())+    data BarSym0 :: (~>) Bool Bool+      where+        BarSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply BarSym0 arg) (BarSym1 arg) =>+                                BarSym0 a0123456789876543210+    type instance Apply BarSym0 a0123456789876543210 = Bar a0123456789876543210+    type FooSym1 (a0123456789876543210 :: Bool) =+        Foo a0123456789876543210+    instance SuppressUnusedWarnings FooSym0 where+      suppressUnusedWarnings = snd (((,) FooSym0KindInference) ())+    data FooSym0 :: (~>) Bool Bool+      where+        FooSym0KindInference :: forall a0123456789876543210+                                       arg. SameKind (Apply FooSym0 arg) (FooSym1 arg) =>+                                FooSym0 a0123456789876543210+    type instance Apply FooSym0 a0123456789876543210 = Foo a0123456789876543210+    type family Bar (a :: Bool) :: Bool where+      Bar a_0123456789876543210 = Apply (Apply ErrorSym0 "urk") a_0123456789876543210+    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)+    sFoo ::+      forall (t :: Bool). Sing t -> Sing (Apply FooSym0 t :: Bool)+    sBar (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = (sError (sing :: Sing "urk")) sA_0123456789876543210+    sFoo (sA_0123456789876543210 :: Sing a_0123456789876543210)+      = sUndefined sA_0123456789876543210+    instance SingI (BarSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @BarSym0) sBar+    instance SingI (FooSym0 :: (~>) Bool Bool) where+      sing = (singFun1 @FooSym0) sFoo