singletons 1.1.2 → 1.1.2.1

raw patch · 13 files changed

+686/−643 lines, 13 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

Files

• CHANGES.md +6/−0
• singletons.cabal +2/−2
• src/Data/Singletons/Names.hs +4/−4
• src/Data/Singletons/Promote.hs +18/−20
• src/Data/Singletons/Util.hs +61/−11
• tests/SingletonsTestSuiteUtils.hs +1/−0
• tests/compile-and-dump/GradingClient/Database.ghc78.template +29/−29
• tests/compile-and-dump/InsertionSort/InsertionSortImp.ghc78.template +23/−23
• tests/compile-and-dump/Singletons/AsPattern.ghc78.template +86/−86
• tests/compile-and-dump/Singletons/CaseExpressions.ghc78.template +83/−83
• tests/compile-and-dump/Singletons/HigherOrder.ghc78.template +58/−58
• tests/compile-and-dump/Singletons/LetStatements.ghc78.template +283/−294
• tests/compile-and-dump/Singletons/PatternMatching.ghc78.template +32/−33

@@ -1,6 +1,12 @@ Changelog for singletons project ================================ +1.1.2.1+-------++Fix bug #116, thus allowing locally-declared symbols to be used in GHC 7.10.++ 1.1.2 ----- 

@@ -1,5 +1,5 @@ name:           singletons-version:        1.1.2+version:        1.1.2.1                 -- Remember to bump version in the Makefile as well cabal-version:  >= 1.10 synopsis:       A framework for generating singleton types@@ -38,7 +38,7 @@ source-repository this   type:     git   location: https://github.com/goldfirere/singletons.git-  tag:      v1.1.2+  tag:      v1.1.2.1  library   hs-source-dirs:     src

@@ -3,7 +3,7 @@ (c) Richard Eisenberg 2014 eir@cis.upenn.edu -Defining names and maniuplations on names for use in promotion and singling.+Defining names and manipulations on names for use in promotion and singling. -}  {-# LANGUAGE CPP, TemplateHaskell #-}@@ -99,8 +99,8 @@ promoteValNameLhs = upcase  -- like promoteValNameLhs, but adds a prefix to the promoted name-promoteValNameLhsPrefix :: String -> Name -> Name-promoteValNameLhsPrefix prefix = mkName . (prefix ++) . toUpcaseStr+promoteValNameLhsPrefix :: (String, String) -> Name -> Name+promoteValNameLhsPrefix pres n = mkName $ toUpcaseStr pres n  -- used when a value name appears in an expression context -- works for both variables and datacons@@ -132,7 +132,7 @@     = mkName $ "Tuple" ++ show degree ++ "Sym" ++ (show sat)      | otherwise-    = let capped = toUpcaseStr name in+    = let capped = toUpcaseStr noPrefix name in       if isHsLetter (head capped)       then mkName (capped ++ "Sym" ++ (show sat))       else mkName (capped ++ (replicate (sat + 1) '$'))

@@ -198,22 +198,19 @@       concatMapM (getRecordSelectors arg_ty) cons  -- curious about ALetDecEnv? See the LetDecEnv module for an explanation.-promoteLetDecs :: String -- prefix to use on all new definitions+promoteLetDecs :: (String, String) -- (alpha, symb) prefixes to use                -> [DLetDec] -> PrM ([LetBind], ALetDecEnv)-promoteLetDecs prefix decls = do+promoteLetDecs prefixes decls = do   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-              , let proName = promoteValNameLhsPrefix prefix name+              , let proName = promoteValNameLhsPrefix prefixes name                     sym = promoteTySym proName (length all_locals) ]-  (decs, let_dec_env') <- letBind binds $ promoteLetDecEnv prefix let_dec_env+  (decs, let_dec_env') <- letBind binds $ promoteLetDecEnv prefixes let_dec_env   emitDecs decs   return (binds, let_dec_env' { lde_proms = Map.fromList binds }) -noPrefix :: String-noPrefix = ""- -- Promotion of data types to kinds is automatic (see "Ginving Haskell a -- Promotion" paper for more details). Here we "plug into" the promotion -- mechanism to add some extra stuff to the promotion:@@ -417,17 +414,17 @@     apply_ki = DSigT  -promoteLetDecEnv :: String -> ULetDecEnv -> PrM ([DDec], ALetDecEnv)-promoteLetDecEnv prefix (LetDecEnv { lde_defns = value_env-                                   , lde_types = type_env-                                   , lde_infix = infix_decls }) = do+promoteLetDecEnv :: (String, String) -> ULetDecEnv -> PrM ([DDec], ALetDecEnv)+promoteLetDecEnv prefixes (LetDecEnv { lde_defns = value_env+                                     , lde_types = type_env+                                     , lde_infix = infix_decls }) = do     -- deal with the infix_decls, to get them out of the way   let infix_decls'  = catMaybes $ map (uncurry promoteInfixDecl) infix_decls      -- promote all the declarations, producing annotated declarations       (names, rhss) = unzip $ Map.toList value_env   (payloads, defun_decss, ann_rhss)-    <- fmap unzip3 $ zipWithM (promoteLetDecRHS type_env prefix) names rhss+    <- fmap unzip3 $ zipWithM (promoteLetDecRHS type_env prefixes) names rhss    emitDecs $ concat defun_decss   let decs = map payload_to_dec payloads@@ -454,7 +451,7 @@ -- let bindings. Thus, it can't quite do all the work locally and returns -- an unwiedly intermediate structure. Perhaps a better design is available. promoteLetDecRHS :: Map Name DType       -- local type env't-                 -> String               -- let-binding prefix+                 -> (String, String)     -- let-binding prefixes                  -> Name                 -- name of the thing being promoted                  -> ULetDecRHS           -- body of the thing                  -> PrM ( Either@@ -463,7 +460,7 @@                                                         -- "type family"                         , [DDec]        -- defunctionalization                         , ALetDecRHS )  -- annotated RHS-promoteLetDecRHS type_env prefix name (UValue exp) = do+promoteLetDecRHS type_env prefixes name (UValue exp) = do   (res_kind, mk_rhs, num_arrows)     <- case Map.lookup name type_env of          Nothing -> return (Nothing, id, 0)@@ -474,7 +471,7 @@     0 -> do       all_locals <- allLocals       (exp', ann_exp) <- promoteExp exp-      let proName = promoteValNameLhsPrefix prefix name+      let proName = promoteValNameLhsPrefix prefixes name       defuns <- defunctionalize proName (map (const Nothing) all_locals) res_kind       return ( Left (proName, map DPlainTV all_locals, mk_rhs exp')              , defuns@@ -484,10 +481,10 @@       names <- replicateM num_arrows (newUniqueName "a")       let pats    = map DVarPa names           newArgs = map DVarE  names-      promoteLetDecRHS type_env prefix name+      promoteLetDecRHS type_env prefixes name                        (UFunction [DClause pats (foldExp exp newArgs)]) -promoteLetDecRHS type_env prefix name (UFunction clauses) = do+promoteLetDecRHS type_env prefixes name (UFunction clauses) = do   numArgs <- count_args clauses   (m_argKs, m_resK, ty_num_args) <- case Map.lookup name type_env of #if __GLASGOW_HASKELL__ < 707@@ -508,7 +505,7 @@       -- invariant: countArgs ty == length argKs       return (map Just argKs, Just resultK, length argKs) -  let proName = promoteValNameLhsPrefix prefix name+  let proName = promoteValNameLhsPrefix prefixes name   all_locals <- allLocals   defun_decs <- defunctionalize proName                 (map (const Nothing) all_locals ++ m_argKs) m_resK@@ -624,8 +621,9 @@   return ( prom_case `DAppT` exp'          , ADCaseE ann_exp ann_matches ) promoteExp (DLetE decs exp) = do-  letPrefix <- fmap nameBase $ newUniqueName "Let"-  (binds, ann_env) <- promoteLetDecs letPrefix decs+  unique <- qNewUnique+  let letPrefixes = uniquePrefixes "Let" ":<<<" unique+  (binds, ann_env) <- promoteLetDecs letPrefixes decs   (exp', ann_exp) <- letBind binds $ promoteExp exp   return (exp', ADLetE ann_env ann_exp) promoteExp (DSigE exp ty) = do

@@ -28,6 +28,7 @@  #if __GLASGOW_HASKELL__ < 709 import Control.Applicative+import GHC.Exts ( Int(I#) ) #endif  -- The list of types that singletons processes by default@@ -57,6 +58,18 @@ qReportError :: DsMonad q => String -> q () qReportError = qReport True +-- | Generate a new Unique+qNewUnique :: DsMonad q => q Int+qNewUnique = do+  Name _ flav <- qNewName "x"+  case flav of+#if __GLASGOW_HASKELL__ >= 709+    NameU n -> return n+#else+    NameU n -> return (I# n)+#endif+    _       -> error "Internal error: `qNewName` didn't return a NameU"+ checkForRep :: DsMonad q => [Name] -> q () checkForRep names =   when (any ((== "Rep") . nameBase) names)@@ -86,22 +99,34 @@  -- make an identifier uppercase upcase :: Name -> Name-upcase = mkName . toUpcaseStr+upcase = mkName . toUpcaseStr noPrefix  -- make an identifier uppercase and return it as a String-toUpcaseStr :: Name -> String-toUpcaseStr n-  |  isUpcase n-  || head (nameBase n) == '$'   -- special case to avoid name clashes. See #29-  = nameBase n+toUpcaseStr :: (String, String)  -- (alpha, symb) prefixes to prepend+            -> Name -> String+toUpcaseStr (alpha, symb) n+  | isHsLetter first+  = upcase_alpha    | otherwise-  = let str   = nameBase n-        first = head str-    in if isHsLetter first-       then (toUpper first) : tail str-       else ':' : str+  = upcase_symb +  where+    str   = nameBase n+    first = head str++    upcase_alpha = alpha ++ (toUpper first) : tail str++    upcase_symb+      |  first == ':'+      || first == '$' -- special case to avoid name clashes. See #29+      = symb ++ str+      | otherwise+      = symb ++ ':' : str++noPrefix :: (String, String)+noPrefix = ("", "")+ -- make an identifier lowercase locase :: Name -> Name locase n =@@ -135,6 +160,31 @@   if isHsLetter first   then mkName (str ++ ident)   else mkName (str ++ symb)++-- convert a number into both alphanumeric and symoblic forms+uniquePrefixes :: String   -- alphanumeric prefix+               -> String   -- symbolic prefix+               -> Int+               -> (String, String)  -- (alphanum, symbolic)+uniquePrefixes alpha symb n = (alpha ++ n_str, symb ++ convert n_str)+  where+    n_str = show n++    convert [] = []+    convert (d : ds) =+      let d' = case d of+                 '0' -> '!'+                 '1' -> '#'+                 '2' -> '$'+                 '3' -> '%'+                 '4' -> '&'+                 '5' -> '*'+                 '6' -> '+'+                 '7' -> '.'+                 '8' -> '/'+                 '9' -> '>'+                 _   -> error "non-digit in show #"+      in d' : convert ds  -- extract the kind from a TyVarBndr. Returns '*' by default. extractTvbKind :: DTyVarBndr -> Maybe DKind

@@ -215,6 +215,7 @@   , "-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/[!#$%&*+./>]\\{10\\}/%%%%%%%%%%/g'"   , file   ] 

@@ -278,45 +278,45 @@       = forall arg. KindOf (Apply SchSym0 arg) ~ KindOf (SchSym1 arg) =>         SchSym0KindInference     type instance Apply SchSym0 l = SchSym1 l-    type Let_0123456789Scrutinee_0123456789Sym4 t t t t =-        Let_0123456789Scrutinee_0123456789 t t t t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym3 where+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =+        Let0123456789Scrutinee_0123456789 t t t t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym3 l l l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>-        Let_0123456789Scrutinee_0123456789Sym3KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where+               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym3 l l l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>+        Let0123456789Scrutinee_0123456789Sym3KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym2 l l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>-        Let_0123456789Scrutinee_0123456789Sym2KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where+               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym2 l l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>+        Let0123456789Scrutinee_0123456789Sym2KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym1 l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>-        Let_0123456789Scrutinee_0123456789Sym1KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym1 l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>+        Let0123456789Scrutinee_0123456789Sym1KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 name name' u attrs =+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 name name' u attrs =         Apply (Apply (:==$) name) name'     type family Case_0123456789 name name' u attrs t where       Case_0123456789 name name' u attrs True = u@@ -398,7 +398,7 @@     type instance Apply AppendSym0 l = AppendSym1 l     type family Lookup (a :: [AChar]) (a :: Schema) :: U where       Lookup z (Sch '[]) = Any-      Lookup name (Sch ((:) (Attr name' u) attrs)) = Case_0123456789 name name' u attrs (Let_0123456789Scrutinee_0123456789Sym4 name name' u attrs)+      Lookup name (Sch ((:) (Attr name' u) attrs)) = Case_0123456789 name name' u attrs (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs)     type family Occurs (a :: [AChar]) (a :: Schema) :: Bool where       Occurs z (Sch '[]) = FalseSym0       Occurs name (Sch ((:) (Attr name' z) attrs)) = Apply (Apply (:||$) (Apply (Apply (:==$) name) name')) (Apply (Apply OccursSym0 name) (Apply SchSym0 attrs))@@ -445,7 +445,7 @@           lambda name name' u attrs             = let                 sScrutinee_0123456789 ::-                  Sing (Let_0123456789Scrutinee_0123456789Sym4 name name' u attrs)+                  Sing (Let0123456789Scrutinee_0123456789Sym4 name name' u attrs)                 sScrutinee_0123456789                   = applySing                       (applySing (singFun2 (Proxy :: Proxy (:==$)) (%:==)) name) name'

@@ -57,36 +57,36 @@     insertionSort :: [Nat] -> [Nat]     insertionSort GHC.Types.[] = []     insertionSort (h GHC.Types.: t) = insert h (insertionSort t)-    type Let_0123456789Scrutinee_0123456789Sym3 t t t =-        Let_0123456789Scrutinee_0123456789 t t t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where+    type Let0123456789Scrutinee_0123456789Sym3 t t t =+        Let0123456789Scrutinee_0123456789 t t t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym2 l l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>-        Let_0123456789Scrutinee_0123456789Sym2KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where+               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym2 l l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>+        Let0123456789Scrutinee_0123456789Sym2KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym1 l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>-        Let_0123456789Scrutinee_0123456789Sym1KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym1 l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>+        Let0123456789Scrutinee_0123456789Sym1KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 n h t =+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 n h t =         Apply (Apply LeqSym0 n) h     type family Case_0123456789 n h t t where       Case_0123456789 n h t True = Apply (Apply (:$) n) (Apply (Apply (:$) h) t)@@ -135,7 +135,7 @@       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_0123456789 n h t (Let_0123456789Scrutinee_0123456789Sym3 n h t)+      Insert n ((:) h t) = Case_0123456789 n h t (Let0123456789Scrutinee_0123456789Sym3 n h t)     type family InsertionSort (a :: [Nat]) :: [Nat] where       InsertionSort '[] = '[]       InsertionSort ((:) h t) = Apply (Apply InsertSym0 h) (Apply InsertionSortSym0 t)@@ -192,7 +192,7 @@           lambda n h t             = let                 sScrutinee_0123456789 ::-                  Sing (Let_0123456789Scrutinee_0123456789Sym3 n h t)+                  Sing (Let0123456789Scrutinee_0123456789Sym3 n h t)                 sScrutinee_0123456789                   = applySing                       (applySing (singFun2 (Proxy :: Proxy LeqSym0) sLeq) n) h

@@ -57,92 +57,92 @@       = forall arg. KindOf (Apply BazSym0 arg) ~ KindOf (BazSym1 arg) =>         BazSym0KindInference     type instance Apply BazSym0 l = BazSym1 l-    type Let_0123456789PSym0 = Let_0123456789P-    type Let_0123456789P = '[]-    type Let_0123456789PSym1 t = Let_0123456789P t-    instance SuppressUnusedWarnings Let_0123456789PSym0 where+    type Let0123456789PSym0 = Let0123456789P+    type Let0123456789P = '[]+    type Let0123456789PSym1 t = Let0123456789P t+    instance SuppressUnusedWarnings Let0123456789PSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())-    data Let_0123456789PSym0 l-      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>-        Let_0123456789PSym0KindInference-    type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l-    type Let_0123456789P wild_0123456789 =+        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())+    data Let0123456789PSym0 l+      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>+        Let0123456789PSym0KindInference+    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l+    type Let0123456789P wild_0123456789 =         Apply (Apply (:$) wild_0123456789) '[]-    type Let_0123456789PSym2 t t = Let_0123456789P t t-    instance SuppressUnusedWarnings Let_0123456789PSym1 where+    type Let0123456789PSym2 t t = Let0123456789P t t+    instance SuppressUnusedWarnings Let0123456789PSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789PSym1KindInference GHC.Tuple.())-    data Let_0123456789PSym1 l l-      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>-        Let_0123456789PSym1KindInference-    type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l-    instance SuppressUnusedWarnings Let_0123456789PSym0 where+        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())+    data Let0123456789PSym1 l l+      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>+        Let0123456789PSym1KindInference+    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l+    instance SuppressUnusedWarnings Let0123456789PSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())-    data Let_0123456789PSym0 l-      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>-        Let_0123456789PSym0KindInference-    type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l-    type Let_0123456789P wild_0123456789 wild_0123456789 =+        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())+    data Let0123456789PSym0 l+      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>+        Let0123456789PSym0KindInference+    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l+    type Let0123456789P wild_0123456789 wild_0123456789 =         Apply (Apply (:$) wild_0123456789) wild_0123456789-    type Let_0123456789PSym2 t t = Let_0123456789P t t-    instance SuppressUnusedWarnings Let_0123456789PSym1 where+    type Let0123456789PSym2 t t = Let0123456789P t t+    instance SuppressUnusedWarnings Let0123456789PSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789PSym1KindInference GHC.Tuple.())-    data Let_0123456789PSym1 l l-      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>-        Let_0123456789PSym1KindInference-    type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l-    instance SuppressUnusedWarnings Let_0123456789PSym0 where+        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())+    data Let0123456789PSym1 l l+      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>+        Let0123456789PSym1KindInference+    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l+    instance SuppressUnusedWarnings Let0123456789PSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())-    data Let_0123456789PSym0 l-      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>-        Let_0123456789PSym0KindInference-    type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l-    type Let_0123456789P wild_0123456789 wild_0123456789 =+        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())+    data Let0123456789PSym0 l+      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>+        Let0123456789PSym0KindInference+    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l+    type Let0123456789P wild_0123456789 wild_0123456789 =         Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789-    type Let_0123456789PSym0 = Let_0123456789P-    type Let_0123456789P = NothingSym0-    type Let_0123456789PSym3 t t t = Let_0123456789P t t t-    instance SuppressUnusedWarnings Let_0123456789PSym2 where+    type Let0123456789PSym0 = Let0123456789P+    type Let0123456789P = NothingSym0+    type Let0123456789PSym3 t t t = Let0123456789P t t t+    instance SuppressUnusedWarnings Let0123456789PSym2 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789PSym2KindInference GHC.Tuple.())-    data Let_0123456789PSym2 l l l-      = forall arg. KindOf (Apply (Let_0123456789PSym2 l l) arg) ~ KindOf (Let_0123456789PSym3 l l arg) =>-        Let_0123456789PSym2KindInference-    type instance Apply (Let_0123456789PSym2 l l) l = Let_0123456789PSym3 l l l-    instance SuppressUnusedWarnings Let_0123456789PSym1 where+        = snd (GHC.Tuple.(,) Let0123456789PSym2KindInference GHC.Tuple.())+    data Let0123456789PSym2 l l l+      = forall arg. KindOf (Apply (Let0123456789PSym2 l l) arg) ~ KindOf (Let0123456789PSym3 l l arg) =>+        Let0123456789PSym2KindInference+    type instance Apply (Let0123456789PSym2 l l) l = Let0123456789PSym3 l l l+    instance SuppressUnusedWarnings Let0123456789PSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789PSym1KindInference GHC.Tuple.())-    data Let_0123456789PSym1 l l-      = forall arg. KindOf (Apply (Let_0123456789PSym1 l) arg) ~ KindOf (Let_0123456789PSym2 l arg) =>-        Let_0123456789PSym1KindInference-    type instance Apply (Let_0123456789PSym1 l) l = Let_0123456789PSym2 l l-    instance SuppressUnusedWarnings Let_0123456789PSym0 where+        = snd (GHC.Tuple.(,) Let0123456789PSym1KindInference GHC.Tuple.())+    data Let0123456789PSym1 l l+      = forall arg. KindOf (Apply (Let0123456789PSym1 l) arg) ~ KindOf (Let0123456789PSym2 l arg) =>+        Let0123456789PSym1KindInference+    type instance Apply (Let0123456789PSym1 l) l = Let0123456789PSym2 l l+    instance SuppressUnusedWarnings Let0123456789PSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789PSym0KindInference GHC.Tuple.())-    data Let_0123456789PSym0 l-      = forall arg. KindOf (Apply Let_0123456789PSym0 arg) ~ KindOf (Let_0123456789PSym1 arg) =>-        Let_0123456789PSym0KindInference-    type instance Apply Let_0123456789PSym0 l = Let_0123456789PSym1 l-    type Let_0123456789P wild_0123456789+        = snd (GHC.Tuple.(,) Let0123456789PSym0KindInference GHC.Tuple.())+    data Let0123456789PSym0 l+      = forall arg. KindOf (Apply Let0123456789PSym0 arg) ~ KindOf (Let0123456789PSym1 arg) =>+        Let0123456789PSym0KindInference+    type instance Apply Let0123456789PSym0 l = Let0123456789PSym1 l+    type Let0123456789P wild_0123456789                          wild_0123456789                          wild_0123456789 =         Apply JustSym0 (Apply (Apply (Apply BazSym0 wild_0123456789) wild_0123456789) wild_0123456789)-    type Let_0123456789XSym1 t = Let_0123456789X t-    instance SuppressUnusedWarnings Let_0123456789XSym0 where+    type Let0123456789XSym1 t = Let0123456789X t+    instance SuppressUnusedWarnings Let0123456789XSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789XSym0KindInference GHC.Tuple.())-    data Let_0123456789XSym0 l-      = forall arg. KindOf (Apply Let_0123456789XSym0 arg) ~ KindOf (Let_0123456789XSym1 arg) =>-        Let_0123456789XSym0KindInference-    type instance Apply Let_0123456789XSym0 l = Let_0123456789XSym1 l-    type Let_0123456789X wild_0123456789 =+        = snd (GHC.Tuple.(,) Let0123456789XSym0KindInference GHC.Tuple.())+    data Let0123456789XSym0 l+      = forall arg. KindOf (Apply Let0123456789XSym0 arg) ~ KindOf (Let0123456789XSym1 arg) =>+        Let0123456789XSym0KindInference+    type instance Apply Let0123456789XSym0 l = Let0123456789XSym1 l+    type Let0123456789X wild_0123456789 =         Apply JustSym0 wild_0123456789-    type Let_0123456789PSym0 = Let_0123456789P-    type Let_0123456789P = NothingSym0+    type Let0123456789PSym0 = Let0123456789P+    type Let0123456789P = NothingSym0     type FooSym1 (t :: [Nat]) = Foo t     instance SuppressUnusedWarnings FooSym0 where       suppressUnusedWarnings _@@ -184,21 +184,21 @@         MaybePlusSym0KindInference     type instance Apply MaybePlusSym0 l = MaybePlusSym1 l     type family Foo (a :: [Nat]) :: [Nat] where-      Foo '[] = Let_0123456789PSym0-      Foo '[wild_0123456789] = Let_0123456789PSym1 wild_0123456789-      Foo ((:) wild_0123456789 wild_0123456789) = Let_0123456789PSym2 wild_0123456789 wild_0123456789+      Foo '[] = Let0123456789PSym0+      Foo '[wild_0123456789] = Let0123456789PSym1 wild_0123456789+      Foo ((:) wild_0123456789 wild_0123456789) = Let0123456789PSym2 wild_0123456789 wild_0123456789     type family Tup (a :: (Nat, Nat)) :: (Nat, Nat) where       Tup '(wild_0123456789,-            wild_0123456789) = Let_0123456789PSym2 wild_0123456789 wild_0123456789+            wild_0123456789) = Let0123456789PSym2 wild_0123456789 wild_0123456789     type family Baz_ (a :: Maybe Baz) :: Maybe Baz where-      Baz_ Nothing = Let_0123456789PSym0-      Baz_ (Just (Baz wild_0123456789 wild_0123456789 wild_0123456789)) = Let_0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789+      Baz_ Nothing = Let0123456789PSym0+      Baz_ (Just (Baz wild_0123456789 wild_0123456789 wild_0123456789)) = Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789     type family Bar (a :: Maybe Nat) :: Maybe Nat where-      Bar (Just wild_0123456789) = Let_0123456789XSym1 wild_0123456789+      Bar (Just wild_0123456789) = Let0123456789XSym1 wild_0123456789       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 = Let_0123456789PSym0+      MaybePlus Nothing = Let0123456789PSym0     sFoo :: forall (t :: [Nat]). Sing t -> Sing (Apply FooSym0 t)     sTup :: forall (t :: (Nat, Nat)). Sing t -> Sing (Apply TupSym0 t)     sBaz_ :: forall (t :: Maybe Baz). Sing t -> Sing (Apply Baz_Sym0 t)@@ -210,7 +210,7 @@           lambda :: t ~ '[] => Sing (Apply FooSym0 '[])           lambda             = let-                sP :: Sing Let_0123456789PSym0+                sP :: Sing Let0123456789PSym0                 sP = SNil               in sP         in lambda@@ -222,7 +222,7 @@             -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) '[]))           lambda wild_0123456789             = let-                sP :: Sing (Let_0123456789PSym1 wild_0123456789)+                sP :: Sing (Let0123456789PSym1 wild_0123456789)                 sP                   = applySing                       (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)@@ -239,7 +239,7 @@                -> Sing (Apply FooSym0 (Apply (Apply (:$) wild_0123456789) wild_0123456789))           lambda wild_0123456789 wild_0123456789             = let-                sP :: Sing (Let_0123456789PSym2 wild_0123456789 wild_0123456789)+                sP :: Sing (Let0123456789PSym2 wild_0123456789 wild_0123456789)                 sP                   = applySing                       (applySing (singFun2 (Proxy :: Proxy (:$)) SCons) wild_0123456789)@@ -256,7 +256,7 @@                -> Sing (Apply TupSym0 (Apply (Apply Tuple2Sym0 wild_0123456789) wild_0123456789))           lambda wild_0123456789 wild_0123456789             = let-                sP :: Sing (Let_0123456789PSym2 wild_0123456789 wild_0123456789)+                sP :: Sing (Let0123456789PSym2 wild_0123456789 wild_0123456789)                 sP                   = applySing                       (applySing@@ -269,7 +269,7 @@           lambda :: t ~ NothingSym0 => Sing (Apply Baz_Sym0 NothingSym0)           lambda             = let-                sP :: Sing Let_0123456789PSym0+                sP :: Sing Let0123456789PSym0                 sP = SNothing               in sP         in lambda@@ -287,7 +287,7 @@           lambda wild_0123456789 wild_0123456789 wild_0123456789             = let                 sP ::-                  Sing (Let_0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789)+                  Sing (Let0123456789PSym3 wild_0123456789 wild_0123456789 wild_0123456789)                 sP                   = applySing                       (singFun1 (Proxy :: Proxy JustSym0) SJust)@@ -307,7 +307,7 @@             -> Sing (Apply BarSym0 (Apply JustSym0 wild_0123456789))           lambda wild_0123456789             = let-                sX :: Sing (Let_0123456789XSym1 wild_0123456789)+                sX :: Sing (Let0123456789XSym1 wild_0123456789)                 sX                   = applySing                       (singFun1 (Proxy :: Proxy JustSym0) SJust) wild_0123456789@@ -337,7 +337,7 @@           lambda :: t ~ NothingSym0 => Sing (Apply MaybePlusSym0 NothingSym0)           lambda             = let-                sP :: Sing Let_0123456789PSym0+                sP :: Sing Let0123456789PSym0                 sP = SNothing               in sP         in lambda

@@ -38,18 +38,18 @@                in z }     foo5 :: forall a. a -> a     foo5 x = case x of { y -> \ _ -> x y }-    type Let_0123456789Scrutinee_0123456789Sym1 t =-        Let_0123456789Scrutinee_0123456789 t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+    type Let0123456789Scrutinee_0123456789Sym1 t =+        Let0123456789Scrutinee_0123456789 t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 x = x+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 x = x     type family Case_0123456789 x y arg_0123456789 t where       Case_0123456789 x y arg_0123456789 z = x     type family Lambda_0123456789 x y t where@@ -81,95 +81,95 @@     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l     type family Case_0123456789 x t where       Case_0123456789 x y = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y-    type Let_0123456789Scrutinee_0123456789Sym1 t =-        Let_0123456789Scrutinee_0123456789 t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+    type Let0123456789Scrutinee_0123456789Sym1 t =+        Let0123456789Scrutinee_0123456789 t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 x = x-    type Let_0123456789ZSym2 t t = Let_0123456789Z t t-    instance SuppressUnusedWarnings Let_0123456789ZSym1 where+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 x = x+    type Let0123456789ZSym2 t t = Let0123456789Z t t+    instance SuppressUnusedWarnings Let0123456789ZSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())-    data Let_0123456789ZSym1 l l-      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>-        Let_0123456789ZSym1KindInference-    type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where+        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())+    data Let0123456789ZSym1 l l+      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>+        Let0123456789ZSym1KindInference+    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l+    instance SuppressUnusedWarnings Let0123456789ZSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())-    data Let_0123456789ZSym0 l-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>-        Let_0123456789ZSym0KindInference-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l-    type Let_0123456789Z x y = (y :: a)+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())+    data Let0123456789ZSym0 l+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>+        Let0123456789ZSym0KindInference+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l+    type Let0123456789Z x y = (y :: a)     type family Case_0123456789 x t where-      Case_0123456789 x y = Let_0123456789ZSym2 x y-    type Let_0123456789Scrutinee_0123456789Sym2 t t =-        Let_0123456789Scrutinee_0123456789 t t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where+      Case_0123456789 x y = Let0123456789ZSym2 x y+    type Let0123456789Scrutinee_0123456789Sym2 t t =+        Let0123456789Scrutinee_0123456789 t t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym1 l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>-        Let_0123456789Scrutinee_0123456789Sym1KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym1 l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>+        Let0123456789Scrutinee_0123456789Sym1KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 a b =+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 a b =         Apply (Apply Tuple2Sym0 a) b     type family Case_0123456789 a b t where       Case_0123456789 a b '(p, z) = p-    type Let_0123456789Scrutinee_0123456789Sym1 t =-        Let_0123456789Scrutinee_0123456789 t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+    type Let0123456789Scrutinee_0123456789Sym1 t =+        Let0123456789Scrutinee_0123456789 t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 d = Apply JustSym0 d+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 d = Apply JustSym0 d     type family Case_0123456789 d t where       Case_0123456789 d (Just y) = y-    type Let_0123456789Scrutinee_0123456789Sym2 t t =-        Let_0123456789Scrutinee_0123456789 t t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where+    type Let0123456789Scrutinee_0123456789Sym2 t t =+        Let0123456789Scrutinee_0123456789 t t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym1 l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>-        Let_0123456789Scrutinee_0123456789Sym1KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym1 l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>+        Let0123456789Scrutinee_0123456789Sym1KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 d x = x+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 d x = x     type family Case_0123456789 d x t where       Case_0123456789 d x (Just y) = y       Case_0123456789 d x Nothing = d@@ -235,15 +235,15 @@         Foo1Sym0KindInference     type instance Apply Foo1Sym0 l = Foo1Sym1 l     type family Foo5 (a :: a) :: a where-      Foo5 x = Case_0123456789 x (Let_0123456789Scrutinee_0123456789Sym1 x)+      Foo5 x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)     type family Foo4 (a :: a) :: a where-      Foo4 x = Case_0123456789 x (Let_0123456789Scrutinee_0123456789Sym1 x)+      Foo4 x = Case_0123456789 x (Let0123456789Scrutinee_0123456789Sym1 x)     type family Foo3 (a :: a) (a :: b) :: a where-      Foo3 a b = Case_0123456789 a b (Let_0123456789Scrutinee_0123456789Sym2 a b)+      Foo3 a b = Case_0123456789 a b (Let0123456789Scrutinee_0123456789Sym2 a b)     type family Foo2 (a :: a) (a :: Maybe a) :: a where-      Foo2 d z = Case_0123456789 d (Let_0123456789Scrutinee_0123456789Sym1 d)+      Foo2 d z = Case_0123456789 d (Let0123456789Scrutinee_0123456789Sym1 d)     type family Foo1 (a :: a) (a :: Maybe a) :: a where-      Foo1 d x = Case_0123456789 d x (Let_0123456789Scrutinee_0123456789Sym2 d x)+      Foo1 d x = Case_0123456789 d x (Let0123456789Scrutinee_0123456789Sym2 d x)     sFoo5 :: forall (t :: a). Sing t -> Sing (Apply Foo5Sym0 t)     sFoo4 :: forall (t :: a). Sing t -> Sing (Apply Foo4Sym0 t)     sFoo3 ::@@ -261,7 +261,7 @@           lambda x             = let                 sScrutinee_0123456789 ::-                  Sing (Let_0123456789Scrutinee_0123456789Sym1 x)+                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)                 sScrutinee_0123456789 = x               in                 case sScrutinee_0123456789 of {@@ -296,7 +296,7 @@           lambda x             = let                 sScrutinee_0123456789 ::-                  Sing (Let_0123456789Scrutinee_0123456789Sym1 x)+                  Sing (Let0123456789Scrutinee_0123456789Sym1 x)                 sScrutinee_0123456789 = x               in                 case sScrutinee_0123456789 of {@@ -305,7 +305,7 @@                          lambda :: forall y. Sing y -> Sing (Case_0123456789 x y)                          lambda y                            = let-                               sZ :: Sing (Let_0123456789ZSym2 x y)+                               sZ :: Sing (Let0123456789ZSym2 x y)                                sZ = y                              in sZ                        in lambda sY }@@ -318,7 +318,7 @@           lambda a b             = let                 sScrutinee_0123456789 ::-                  Sing (Let_0123456789Scrutinee_0123456789Sym2 a b)+                  Sing (Let0123456789Scrutinee_0123456789Sym2 a b)                 sScrutinee_0123456789                   = applySing                       (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) a) b@@ -341,7 +341,7 @@           lambda d             = let                 sScrutinee_0123456789 ::-                  Sing (Let_0123456789Scrutinee_0123456789Sym1 d)+                  Sing (Let0123456789Scrutinee_0123456789Sym1 d)                 sScrutinee_0123456789                   = applySing (singFun1 (Proxy :: Proxy JustSym0) SJust) d               in@@ -361,7 +361,7 @@           lambda d x             = let                 sScrutinee_0123456789 ::-                  Sing (Let_0123456789Scrutinee_0123456789Sym2 d x)+                  Sing (Let0123456789Scrutinee_0123456789Sym2 d x)                 sScrutinee_0123456789 = x               in                 case sScrutinee_0123456789 of {

@@ -58,50 +58,50 @@       = forall arg. KindOf (Apply RightSym0 arg) ~ KindOf (RightSym1 arg) =>         RightSym0KindInference     type instance Apply RightSym0 l = RightSym1 l-    type Let_0123456789Scrutinee_0123456789Sym4 t t t t =-        Let_0123456789Scrutinee_0123456789 t t t t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym3 where+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =+        Let0123456789Scrutinee_0123456789 t t t t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym3 l l l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>-        Let_0123456789Scrutinee_0123456789Sym3KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where+               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym3 l l l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>+        Let0123456789Scrutinee_0123456789Sym3KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym2 l l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>-        Let_0123456789Scrutinee_0123456789Sym2KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where+               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym2 l l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>+        Let0123456789Scrutinee_0123456789Sym2KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym1 l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>-        Let_0123456789Scrutinee_0123456789Sym1KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym1 l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>+        Let0123456789Scrutinee_0123456789Sym1KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 ns bs n b = b+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 ns bs n b = b     type family Case_0123456789 ns bs n b t where       Case_0123456789 ns bs n b True = Apply SuccSym0 (Apply SuccSym0 n)       Case_0123456789 ns bs n b False = n     type family Lambda_0123456789 ns bs t t where-      Lambda_0123456789 ns bs n b = Case_0123456789 ns bs n b (Let_0123456789Scrutinee_0123456789Sym4 ns bs n b)+      Lambda_0123456789 ns bs n b = Case_0123456789 ns bs n b (Let0123456789Scrutinee_0123456789Sym4 ns bs n b)     type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t     instance SuppressUnusedWarnings Lambda_0123456789Sym3 where       suppressUnusedWarnings _@@ -135,45 +135,45 @@       = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>         Lambda_0123456789Sym0KindInference     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789Sym4 t t t t =-        Let_0123456789Scrutinee_0123456789 t t t t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym3 where+    type Let0123456789Scrutinee_0123456789Sym4 t t t t =+        Let0123456789Scrutinee_0123456789 t t t t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym3 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym3 l l l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym4 l l l arg) =>-        Let_0123456789Scrutinee_0123456789Sym3KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym3 l l l) l = Let_0123456789Scrutinee_0123456789Sym4 l l l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym2 where+               Let0123456789Scrutinee_0123456789Sym3KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym3 l l l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym4 l l l arg) =>+        Let0123456789Scrutinee_0123456789Sym3KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym3 l l l) l = Let0123456789Scrutinee_0123456789Sym4 l l l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym2 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym2 l l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym3 l l arg) =>-        Let_0123456789Scrutinee_0123456789Sym2KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym2 l l) l = Let_0123456789Scrutinee_0123456789Sym3 l l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where+               Let0123456789Scrutinee_0123456789Sym2KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym2 l l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym2 l l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym3 l l arg) =>+        Let0123456789Scrutinee_0123456789Sym2KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym2 l l) l = Let0123456789Scrutinee_0123456789Sym3 l l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym1 l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>-        Let_0123456789Scrutinee_0123456789Sym1KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym1 l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>+        Let0123456789Scrutinee_0123456789Sym1KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 n+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 n                                             b                                             a_0123456789                                             a_0123456789 =@@ -182,7 +182,7 @@       Case_0123456789 n b a_0123456789 a_0123456789 True = Apply SuccSym0 (Apply SuccSym0 n)       Case_0123456789 n b a_0123456789 a_0123456789 False = n     type family Lambda_0123456789 a_0123456789 a_0123456789 t t where-      Lambda_0123456789 a_0123456789 a_0123456789 n b = Case_0123456789 n b a_0123456789 a_0123456789 (Let_0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)+      Lambda_0123456789 a_0123456789 a_0123456789 n b = Case_0123456789 n b a_0123456789 a_0123456789 (Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)     type Lambda_0123456789Sym4 t t t t = Lambda_0123456789 t t t t     instance SuppressUnusedWarnings Lambda_0123456789Sym3 where       suppressUnusedWarnings _@@ -459,7 +459,7 @@                                  lambda n b                                    = let                                        sScrutinee_0123456789 ::-                                         Sing (Let_0123456789Scrutinee_0123456789Sym4 ns bs n b)+                                         Sing (Let0123456789Scrutinee_0123456789Sym4 ns bs n b)                                        sScrutinee_0123456789 = b                                      in                                        case sScrutinee_0123456789 of {@@ -508,7 +508,7 @@                                  lambda n b                                    = let                                        sScrutinee_0123456789 ::-                                         Sing (Let_0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)+                                         Sing (Let0123456789Scrutinee_0123456789Sym4 n b a_0123456789 a_0123456789)                                        sScrutinee_0123456789 = b                                      in                                        case sScrutinee_0123456789 of {

@@ -194,145 +194,135 @@       Case_0123456789 x '(y_0123456789, z) = y_0123456789     type family Case_0123456789 x t where       Case_0123456789 x '(z, y_0123456789) = y_0123456789-    type Let_0123456789YSym1 t = Let_0123456789Y t-    instance SuppressUnusedWarnings Let_0123456789YSym0 where+    type Let0123456789YSym1 t = Let0123456789Y t+    instance SuppressUnusedWarnings Let0123456789YSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789YSym0KindInference GHC.Tuple.())-    data Let_0123456789YSym0 l-      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>-        Let_0123456789YSym0KindInference-    type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l-    type Let_0123456789ZSym1 t = Let_0123456789Z t-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where+        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())+    data Let0123456789YSym0 l+      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>+        Let0123456789YSym0KindInference+    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l+    type Let0123456789ZSym1 t = Let0123456789Z t+    instance SuppressUnusedWarnings Let0123456789ZSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())-    data Let_0123456789ZSym0 l-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>-        Let_0123456789ZSym0KindInference-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l-    type Let_0123456789X_0123456789Sym1 t =-        Let_0123456789X_0123456789 t-    instance SuppressUnusedWarnings Let_0123456789X_0123456789Sym0 where+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())+    data Let0123456789ZSym0 l+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>+        Let0123456789ZSym0KindInference+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l+    type Let0123456789X_0123456789Sym1 t = Let0123456789X_0123456789 t+    instance SuppressUnusedWarnings Let0123456789X_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789X_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789X_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789X_0123456789Sym0 arg) ~ KindOf (Let_0123456789X_0123456789Sym1 arg) =>-        Let_0123456789X_0123456789Sym0KindInference-    type instance Apply Let_0123456789X_0123456789Sym0 l = Let_0123456789X_0123456789Sym1 l-    type Let_0123456789Y x =-        Case_0123456789 x (Let_0123456789X_0123456789Sym1 x)-    type Let_0123456789Z x =-        Case_0123456789 x (Let_0123456789X_0123456789Sym1 x)-    type Let_0123456789X_0123456789 x =+               Let0123456789X_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789X_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789X_0123456789Sym0 arg) ~ KindOf (Let0123456789X_0123456789Sym1 arg) =>+        Let0123456789X_0123456789Sym0KindInference+    type instance Apply Let0123456789X_0123456789Sym0 l = Let0123456789X_0123456789Sym1 l+    type Let0123456789Y x =+        Case_0123456789 x (Let0123456789X_0123456789Sym1 x)+    type Let0123456789Z x =+        Case_0123456789 x (Let0123456789X_0123456789Sym1 x)+    type Let0123456789X_0123456789 x =         Apply (Apply Tuple2Sym0 (Apply SuccSym0 x)) x-    type Let_0123456789BarSym1 t = Let_0123456789Bar t-    instance SuppressUnusedWarnings Let_0123456789BarSym0 where+    type Let0123456789BarSym1 t = Let0123456789Bar t+    instance SuppressUnusedWarnings Let0123456789BarSym0 where       suppressUnusedWarnings _         = snd-            (GHC.Tuple.(,) Let_0123456789BarSym0KindInference GHC.Tuple.())-    data Let_0123456789BarSym0 l-      = forall arg. KindOf (Apply Let_0123456789BarSym0 arg) ~ KindOf (Let_0123456789BarSym1 arg) =>-        Let_0123456789BarSym0KindInference-    type instance Apply Let_0123456789BarSym0 l = Let_0123456789BarSym1 l-    type Let_0123456789Bar x = (x :: a)-    type Let_0123456789:+Sym3 t (t :: Nat) (t :: Nat) =-        Let_0123456789:+ t t t-    instance SuppressUnusedWarnings Let_0123456789:+Sym2 where+            (GHC.Tuple.(,) Let0123456789BarSym0KindInference GHC.Tuple.())+    data Let0123456789BarSym0 l+      = forall arg. KindOf (Apply Let0123456789BarSym0 arg) ~ KindOf (Let0123456789BarSym1 arg) =>+        Let0123456789BarSym0KindInference+    type instance Apply Let0123456789BarSym0 l = Let0123456789BarSym1 l+    type Let0123456789Bar x = (x :: a)+    type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =+        (:<<<%%%%%%%%%%:+) t t t+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())-    data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)-      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>-        Let_0123456789:+Sym2KindInference-    type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l-    instance SuppressUnusedWarnings Let_0123456789:+Sym1 where+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>+        (:<<<%%%%%%%%%%:+$$$###)+    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())-    data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))-      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>-        Let_0123456789:+Sym1KindInference-    type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789:+Sym0 where+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>+        (:<<<%%%%%%%%%%:+$$###)+    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())-    data Let_0123456789:+Sym0 l-      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>-        Let_0123456789:+Sym0KindInference-    type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l-    type family Let_0123456789:+ x (a :: Nat) (a :: Nat) :: Nat where-      Let_0123456789:+ x Zero m = m-      Let_0123456789:+ x (Succ n) m = Apply SuccSym0 (Apply (Apply (Let_0123456789:+Sym1 x) n) x)-    type Let_0123456789ZSym1 t = Let_0123456789Z t-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$) l+      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>+        (:<<<%%%%%%%%%%:+$###)+    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l+    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 Let0123456789ZSym1 t = Let0123456789Z t+    instance SuppressUnusedWarnings Let0123456789ZSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())-    data Let_0123456789ZSym0 l-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>-        Let_0123456789ZSym0KindInference-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l-    type Let_0123456789:+Sym3 t (t :: Nat) (t :: Nat) =-        Let_0123456789:+ t t t-    instance SuppressUnusedWarnings Let_0123456789:+Sym2 where+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())+    data Let0123456789ZSym0 l+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>+        Let0123456789ZSym0KindInference+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l+    type (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =+        (:<<<%%%%%%%%%%:+) t t t+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())-    data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)-      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>-        Let_0123456789:+Sym2KindInference-    type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l-    instance SuppressUnusedWarnings Let_0123456789:+Sym1 where+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>+        (:<<<%%%%%%%%%%:+$$$###)+    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())-    data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))-      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>-        Let_0123456789:+Sym1KindInference-    type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789:+Sym0 where+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>+        (:<<<%%%%%%%%%%:+$$###)+    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())-    data Let_0123456789:+Sym0 l-      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>-        Let_0123456789:+Sym0KindInference-    type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l-    type Let_0123456789Z x = (x :: Nat)-    type family Let_0123456789:+ x (a :: Nat) (a :: Nat) :: Nat where-      Let_0123456789:+ x Zero m = m-      Let_0123456789:+ x (Succ n) m = Apply SuccSym0 (Apply (Apply (Let_0123456789:+Sym1 x) n) m)-    type Let_0123456789:+Sym3 t (t :: Nat) (t :: Nat) =-        Let_0123456789:+ t t t-    instance SuppressUnusedWarnings Let_0123456789:+Sym2 where+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$) l+      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>+        (:<<<%%%%%%%%%%:+$###)+    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l+    type Let0123456789Z x = (x :: Nat)+    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 (:<<<%%%%%%%%%%:+$$$$) t (t :: Nat) (t :: Nat) =+        (:<<<%%%%%%%%%%:+) t t t+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym2KindInference GHC.Tuple.())-    data Let_0123456789:+Sym2 l (l :: Nat) (l :: TyFun Nat Nat)-      = forall arg. KindOf (Apply (Let_0123456789:+Sym2 l l) arg) ~ KindOf (Let_0123456789:+Sym3 l l arg) =>-        Let_0123456789:+Sym2KindInference-    type instance Apply (Let_0123456789:+Sym2 l l) l = Let_0123456789:+Sym3 l l l-    instance SuppressUnusedWarnings Let_0123456789:+Sym1 where+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$$$) l (l :: Nat) (l :: TyFun Nat Nat)+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$$) l l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$$) l l arg) =>+        (:<<<%%%%%%%%%%:+$$$###)+    type instance Apply ((:<<<%%%%%%%%%%:+$$$) l l) l = (:<<<%%%%%%%%%%:+$$$$) l l l+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym1KindInference GHC.Tuple.())-    data Let_0123456789:+Sym1 l (l :: TyFun Nat (TyFun Nat Nat -> *))-      = forall arg. KindOf (Apply (Let_0123456789:+Sym1 l) arg) ~ KindOf (Let_0123456789:+Sym2 l arg) =>-        Let_0123456789:+Sym1KindInference-    type instance Apply (Let_0123456789:+Sym1 l) l = Let_0123456789:+Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789:+Sym0 where+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$$) l (l :: TyFun Nat (TyFun Nat Nat -> *))+      = forall arg. KindOf (Apply ((:<<<%%%%%%%%%%:+$$) l) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$$) l arg) =>+        (:<<<%%%%%%%%%%:+$$###)+    type instance Apply ((:<<<%%%%%%%%%%:+$$) l) l = (:<<<%%%%%%%%%%:+$$$) l l+    instance SuppressUnusedWarnings (:<<<%%%%%%%%%%:+$) where       suppressUnusedWarnings _-        = snd-            (GHC.Tuple.(,) Let_0123456789:+Sym0KindInference GHC.Tuple.())-    data Let_0123456789:+Sym0 l-      = forall arg. KindOf (Apply Let_0123456789:+Sym0 arg) ~ KindOf (Let_0123456789:+Sym1 arg) =>-        Let_0123456789:+Sym0KindInference-    type instance Apply Let_0123456789:+Sym0 l = Let_0123456789:+Sym1 l-    type family Let_0123456789:+ x (a :: Nat) (a :: Nat) :: Nat where-      Let_0123456789:+ x Zero m = m-      Let_0123456789:+ x (Succ n) m = Apply SuccSym0 (Apply (Apply (Let_0123456789:+Sym1 x) n) m)+        = snd (GHC.Tuple.(,) (:<<<%%%%%%%%%%:+$###) GHC.Tuple.())+    data (:<<<%%%%%%%%%%:+$) l+      = forall arg. KindOf (Apply (:<<<%%%%%%%%%%:+$) arg) ~ KindOf ((:<<<%%%%%%%%%%:+$$) arg) =>+        (:<<<%%%%%%%%%%:+$###)+    type instance Apply (:<<<%%%%%%%%%%:+$) l = (:<<<%%%%%%%%%%:+$$) l+    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_0123456789 x a_0123456789 t where       Lambda_0123456789 x a_0123456789 x = x     type Lambda_0123456789Sym3 t t t = Lambda_0123456789 t t t@@ -360,23 +350,23 @@       = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>         Lambda_0123456789Sym0KindInference     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l-    type Let_0123456789ZSym2 t (t :: Nat) = Let_0123456789Z t t-    instance SuppressUnusedWarnings Let_0123456789ZSym1 where+    type Let0123456789ZSym2 t (t :: Nat) = Let0123456789Z t t+    instance SuppressUnusedWarnings Let0123456789ZSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())-    data Let_0123456789ZSym1 l (l :: TyFun Nat Nat)-      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>-        Let_0123456789ZSym1KindInference-    type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where+        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())+    data Let0123456789ZSym1 l (l :: TyFun Nat Nat)+      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>+        Let0123456789ZSym1KindInference+    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l+    instance SuppressUnusedWarnings Let0123456789ZSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())-    data Let_0123456789ZSym0 l-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>-        Let_0123456789ZSym0KindInference-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l-    type family Let_0123456789Z x (a :: Nat) :: Nat where-      Let_0123456789Z x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())+    data Let0123456789ZSym0 l+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>+        Let0123456789ZSym0KindInference+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l+    type family Let0123456789Z x (a :: Nat) :: Nat where+      Let0123456789Z x a_0123456789 = Apply (Apply (Apply Lambda_0123456789Sym0 x) a_0123456789) a_0123456789     type family Lambda_0123456789 x t where       Lambda_0123456789 x x = x     type Lambda_0123456789Sym2 t t = Lambda_0123456789 t t@@ -396,123 +386,123 @@       = forall arg. KindOf (Apply Lambda_0123456789Sym0 arg) ~ KindOf (Lambda_0123456789Sym1 arg) =>         Lambda_0123456789Sym0KindInference     type instance Apply Lambda_0123456789Sym0 l = Lambda_0123456789Sym1 l-    type Let_0123456789ZSym1 t = Let_0123456789Z t-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where+    type Let0123456789ZSym1 t = Let0123456789Z t+    instance SuppressUnusedWarnings Let0123456789ZSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())-    data Let_0123456789ZSym0 l-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>-        Let_0123456789ZSym0KindInference-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l-    type Let_0123456789Z x =+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())+    data Let0123456789ZSym0 l+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>+        Let0123456789ZSym0KindInference+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l+    type Let0123456789Z x =         (Apply (Apply Lambda_0123456789Sym0 x) ZeroSym0 :: Nat)-    type Let_0123456789XSym1 t = Let_0123456789X t-    instance SuppressUnusedWarnings Let_0123456789XSym0 where+    type Let0123456789XSym1 t = Let0123456789X t+    instance SuppressUnusedWarnings Let0123456789XSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789XSym0KindInference GHC.Tuple.())-    data Let_0123456789XSym0 l-      = forall arg. KindOf (Apply Let_0123456789XSym0 arg) ~ KindOf (Let_0123456789XSym1 arg) =>-        Let_0123456789XSym0KindInference-    type instance Apply Let_0123456789XSym0 l = Let_0123456789XSym1 l-    type Let_0123456789X x = (ZeroSym0 :: Nat)-    type Let_0123456789FSym2 t (t :: Nat) = Let_0123456789F t t-    instance SuppressUnusedWarnings Let_0123456789FSym1 where+        = snd (GHC.Tuple.(,) Let0123456789XSym0KindInference GHC.Tuple.())+    data Let0123456789XSym0 l+      = forall arg. KindOf (Apply Let0123456789XSym0 arg) ~ KindOf (Let0123456789XSym1 arg) =>+        Let0123456789XSym0KindInference+    type instance Apply Let0123456789XSym0 l = Let0123456789XSym1 l+    type Let0123456789X x = (ZeroSym0 :: Nat)+    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t+    instance SuppressUnusedWarnings Let0123456789FSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789FSym1KindInference GHC.Tuple.())-    data Let_0123456789FSym1 l (l :: TyFun Nat Nat)-      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>-        Let_0123456789FSym1KindInference-    type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l-    instance SuppressUnusedWarnings Let_0123456789FSym0 where+        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())+    data Let0123456789FSym1 l (l :: TyFun Nat Nat)+      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>+        Let0123456789FSym1KindInference+    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l+    instance SuppressUnusedWarnings Let0123456789FSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789FSym0KindInference GHC.Tuple.())-    data Let_0123456789FSym0 l-      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>-        Let_0123456789FSym0KindInference-    type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l-    type family Let_0123456789F x (a :: Nat) :: Nat where-      Let_0123456789F x y = Apply SuccSym0 y-    type Let_0123456789ZSym1 t = Let_0123456789Z t-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where+        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())+    data Let0123456789FSym0 l+      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>+        Let0123456789FSym0KindInference+    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l+    type family Let0123456789F x (a :: Nat) :: Nat where+      Let0123456789F x y = Apply SuccSym0 y+    type Let0123456789ZSym1 t = Let0123456789Z t+    instance SuppressUnusedWarnings Let0123456789ZSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())-    data Let_0123456789ZSym0 l-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>-        Let_0123456789ZSym0KindInference-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l-    type Let_0123456789Z x = (Apply (Let_0123456789FSym1 x) x :: Nat)-    type Let_0123456789ZSym2 t t = Let_0123456789Z t t-    instance SuppressUnusedWarnings Let_0123456789ZSym1 where+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())+    data Let0123456789ZSym0 l+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>+        Let0123456789ZSym0KindInference+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l+    type Let0123456789Z x = (Apply (Let0123456789FSym1 x) x :: Nat)+    type Let0123456789ZSym2 t t = Let0123456789Z t t+    instance SuppressUnusedWarnings Let0123456789ZSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym1KindInference GHC.Tuple.())-    data Let_0123456789ZSym1 l l-      = forall arg. KindOf (Apply (Let_0123456789ZSym1 l) arg) ~ KindOf (Let_0123456789ZSym2 l arg) =>-        Let_0123456789ZSym1KindInference-    type instance Apply (Let_0123456789ZSym1 l) l = Let_0123456789ZSym2 l l-    instance SuppressUnusedWarnings Let_0123456789ZSym0 where+        = snd (GHC.Tuple.(,) Let0123456789ZSym1KindInference GHC.Tuple.())+    data Let0123456789ZSym1 l l+      = forall arg. KindOf (Apply (Let0123456789ZSym1 l) arg) ~ KindOf (Let0123456789ZSym2 l arg) =>+        Let0123456789ZSym1KindInference+    type instance Apply (Let0123456789ZSym1 l) l = Let0123456789ZSym2 l l+    instance SuppressUnusedWarnings Let0123456789ZSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789ZSym0KindInference GHC.Tuple.())-    data Let_0123456789ZSym0 l-      = forall arg. KindOf (Apply Let_0123456789ZSym0 arg) ~ KindOf (Let_0123456789ZSym1 arg) =>-        Let_0123456789ZSym0KindInference-    type instance Apply Let_0123456789ZSym0 l = Let_0123456789ZSym1 l-    type Let_0123456789Z x y = (Apply SuccSym0 y :: Nat)-    type Let_0123456789FSym2 t (t :: Nat) = Let_0123456789F t t-    instance SuppressUnusedWarnings Let_0123456789FSym1 where+        = snd (GHC.Tuple.(,) Let0123456789ZSym0KindInference GHC.Tuple.())+    data Let0123456789ZSym0 l+      = forall arg. KindOf (Apply Let0123456789ZSym0 arg) ~ KindOf (Let0123456789ZSym1 arg) =>+        Let0123456789ZSym0KindInference+    type instance Apply Let0123456789ZSym0 l = Let0123456789ZSym1 l+    type Let0123456789Z x y = (Apply SuccSym0 y :: Nat)+    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t+    instance SuppressUnusedWarnings Let0123456789FSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789FSym1KindInference GHC.Tuple.())-    data Let_0123456789FSym1 l (l :: TyFun Nat Nat)-      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>-        Let_0123456789FSym1KindInference-    type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l-    instance SuppressUnusedWarnings Let_0123456789FSym0 where+        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())+    data Let0123456789FSym1 l (l :: TyFun Nat Nat)+      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>+        Let0123456789FSym1KindInference+    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l+    instance SuppressUnusedWarnings Let0123456789FSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789FSym0KindInference GHC.Tuple.())-    data Let_0123456789FSym0 l-      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>-        Let_0123456789FSym0KindInference-    type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l-    type family Let_0123456789F x (a :: Nat) :: Nat where-      Let_0123456789F x y = Apply SuccSym0 (Let_0123456789ZSym2 x y)-    type Let_0123456789FSym2 t (t :: Nat) = Let_0123456789F t t-    instance SuppressUnusedWarnings Let_0123456789FSym1 where+        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())+    data Let0123456789FSym0 l+      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>+        Let0123456789FSym0KindInference+    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l+    type family Let0123456789F x (a :: Nat) :: Nat where+      Let0123456789F x y = Apply SuccSym0 (Let0123456789ZSym2 x y)+    type Let0123456789FSym2 t (t :: Nat) = Let0123456789F t t+    instance SuppressUnusedWarnings Let0123456789FSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789FSym1KindInference GHC.Tuple.())-    data Let_0123456789FSym1 l (l :: TyFun Nat Nat)-      = forall arg. KindOf (Apply (Let_0123456789FSym1 l) arg) ~ KindOf (Let_0123456789FSym2 l arg) =>-        Let_0123456789FSym1KindInference-    type instance Apply (Let_0123456789FSym1 l) l = Let_0123456789FSym2 l l-    instance SuppressUnusedWarnings Let_0123456789FSym0 where+        = snd (GHC.Tuple.(,) Let0123456789FSym1KindInference GHC.Tuple.())+    data Let0123456789FSym1 l (l :: TyFun Nat Nat)+      = forall arg. KindOf (Apply (Let0123456789FSym1 l) arg) ~ KindOf (Let0123456789FSym2 l arg) =>+        Let0123456789FSym1KindInference+    type instance Apply (Let0123456789FSym1 l) l = Let0123456789FSym2 l l+    instance SuppressUnusedWarnings Let0123456789FSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789FSym0KindInference GHC.Tuple.())-    data Let_0123456789FSym0 l-      = forall arg. KindOf (Apply Let_0123456789FSym0 arg) ~ KindOf (Let_0123456789FSym1 arg) =>-        Let_0123456789FSym0KindInference-    type instance Apply Let_0123456789FSym0 l = Let_0123456789FSym1 l-    type family Let_0123456789F x (a :: Nat) :: Nat where-      Let_0123456789F x y = Apply SuccSym0 y-    type Let_0123456789YSym1 t = Let_0123456789Y t-    instance SuppressUnusedWarnings Let_0123456789YSym0 where+        = snd (GHC.Tuple.(,) Let0123456789FSym0KindInference GHC.Tuple.())+    data Let0123456789FSym0 l+      = forall arg. KindOf (Apply Let0123456789FSym0 arg) ~ KindOf (Let0123456789FSym1 arg) =>+        Let0123456789FSym0KindInference+    type instance Apply Let0123456789FSym0 l = Let0123456789FSym1 l+    type family Let0123456789F x (a :: Nat) :: Nat where+      Let0123456789F x y = Apply SuccSym0 y+    type Let0123456789YSym1 t = Let0123456789Y t+    instance SuppressUnusedWarnings Let0123456789YSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789YSym0KindInference GHC.Tuple.())-    data Let_0123456789YSym0 l-      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>-        Let_0123456789YSym0KindInference-    type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l-    type Let_0123456789Y x = (Apply SuccSym0 x :: Nat)-    type Let_0123456789YSym0 = Let_0123456789Y-    type Let_0123456789ZSym0 = Let_0123456789Z-    type Let_0123456789Y = Apply SuccSym0 ZeroSym0-    type Let_0123456789Z = Apply SuccSym0 Let_0123456789YSym0-    type Let_0123456789YSym1 t = Let_0123456789Y t-    instance SuppressUnusedWarnings Let_0123456789YSym0 where+        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())+    data Let0123456789YSym0 l+      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>+        Let0123456789YSym0KindInference+    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l+    type Let0123456789Y x = (Apply SuccSym0 x :: Nat)+    type Let0123456789YSym0 = Let0123456789Y+    type Let0123456789ZSym0 = Let0123456789Z+    type Let0123456789Y = Apply SuccSym0 ZeroSym0+    type Let0123456789Z = Apply SuccSym0 Let0123456789YSym0+    type Let0123456789YSym1 t = Let0123456789Y t+    instance SuppressUnusedWarnings Let0123456789YSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789YSym0KindInference GHC.Tuple.())-    data Let_0123456789YSym0 l-      = forall arg. KindOf (Apply Let_0123456789YSym0 arg) ~ KindOf (Let_0123456789YSym1 arg) =>-        Let_0123456789YSym0KindInference-    type instance Apply Let_0123456789YSym0 l = Let_0123456789YSym1 l-    type Let_0123456789Y x = (Apply SuccSym0 ZeroSym0 :: Nat)+        = snd (GHC.Tuple.(,) Let0123456789YSym0KindInference GHC.Tuple.())+    data Let0123456789YSym0 l+      = forall arg. KindOf (Apply Let0123456789YSym0 arg) ~ KindOf (Let0123456789YSym1 arg) =>+        Let0123456789YSym0KindInference+    type instance Apply Let0123456789YSym0 l = Let0123456789YSym1 l+    type Let0123456789Y x = (Apply SuccSym0 ZeroSym0 :: Nat)     type Foo14Sym1 (t :: Nat) = Foo14 t     instance SuppressUnusedWarnings Foo14Sym0 where       suppressUnusedWarnings _@@ -627,34 +617,34 @@         Foo1Sym0KindInference     type instance Apply Foo1Sym0 l = Foo1Sym1 l     type family Foo14 (a :: Nat) :: (Nat, Nat) where-      Foo14 x = Apply (Apply Tuple2Sym0 (Let_0123456789ZSym1 x)) (Let_0123456789YSym1 x)+      Foo14 x = Apply (Apply Tuple2Sym0 (Let0123456789ZSym1 x)) (Let0123456789YSym1 x)     type family Foo13_ (a :: a) :: a where       Foo13_ y = y     type family Foo13 (a :: a) :: a where-      Foo13 x = Apply Foo13_Sym0 (Let_0123456789BarSym1 x)+      Foo13 x = Apply Foo13_Sym0 (Let0123456789BarSym1 x)     type family Foo12 (a :: Nat) :: Nat where-      Foo12 x = Apply (Apply (Let_0123456789:+Sym1 x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))+      Foo12 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) x) (Apply SuccSym0 (Apply SuccSym0 ZeroSym0))     type family Foo11 (a :: Nat) :: Nat where-      Foo11 x = Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 ZeroSym0)) (Let_0123456789ZSym1 x)+      Foo11 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) (Let0123456789ZSym1 x)     type family Foo10 (a :: Nat) :: Nat where-      Foo10 x = Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 ZeroSym0)) x+      Foo10 x = Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 ZeroSym0)) x     type family Foo9 (a :: Nat) :: Nat where-      Foo9 x = Apply (Let_0123456789ZSym1 x) x+      Foo9 x = Apply (Let0123456789ZSym1 x) x     type family Foo8 (a :: Nat) :: Nat where-      Foo8 x = Let_0123456789ZSym1 x+      Foo8 x = Let0123456789ZSym1 x     type family Foo7 (a :: Nat) :: Nat where-      Foo7 x = Let_0123456789XSym1 x+      Foo7 x = Let0123456789XSym1 x     type family Foo6 (a :: Nat) :: Nat where-      Foo6 x = Let_0123456789ZSym1 x+      Foo6 x = Let0123456789ZSym1 x     type family Foo5 (a :: Nat) :: Nat where-      Foo5 x = Apply (Let_0123456789FSym1 x) x+      Foo5 x = Apply (Let0123456789FSym1 x) x     type family Foo4 (a :: Nat) :: Nat where-      Foo4 x = Apply (Let_0123456789FSym1 x) x+      Foo4 x = Apply (Let0123456789FSym1 x) x     type family Foo3 (a :: Nat) :: Nat where-      Foo3 x = Let_0123456789YSym1 x-    type Foo2 = (Let_0123456789ZSym0 :: Nat)+      Foo3 x = Let0123456789YSym1 x+    type Foo2 = (Let0123456789ZSym0 :: Nat)     type family Foo1 (a :: Nat) :: Nat where-      Foo1 x = Let_0123456789YSym1 x+      Foo1 x = Let0123456789YSym1 x     sFoo14 :: forall (t :: Nat). Sing t -> Sing (Apply Foo14Sym0 t)     sFoo13_ :: forall (t :: a). Sing t -> Sing (Apply Foo13_Sym0 t)     sFoo13 :: forall (t :: a). Sing t -> Sing (Apply Foo13Sym0 t)@@ -675,9 +665,9 @@           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo14Sym0 x)           lambda x             = let-                sY :: Sing (Let_0123456789YSym1 x)-                sZ :: Sing (Let_0123456789ZSym1 x)-                sX_0123456789 :: Sing (Let_0123456789X_0123456789Sym1 x)+                sY :: Sing (Let0123456789YSym1 x)+                sZ :: Sing (Let0123456789ZSym1 x)+                sX_0123456789 :: Sing (Let0123456789X_0123456789Sym1 x)                 sY                   = case sX_0123456789 of {                       STuple2 sY_0123456789 _@@ -718,7 +708,7 @@           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo13Sym0 x)           lambda x             = let-                sBar :: Sing (Let_0123456789BarSym1 x)+                sBar :: Sing (Let0123456789BarSym1 x)                 sBar = x               in applySing (singFun1 (Proxy :: Proxy Foo13_Sym0) sFoo13_) sBar         in lambda sX@@ -730,12 +720,12 @@                 (%:+) ::                   forall t t.                   Sing t-                  -> Sing t -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) t) t)+                  -> Sing t -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t)                 (%:+) SZero sM                   = let                       lambda ::                         forall m. (t ~ ZeroSym0, t ~ m) =>-                        Sing m -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) ZeroSym0) m)+                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)                       lambda m = m                     in lambda sM                 (%:+) (SSucc sN) sM@@ -744,19 +734,19 @@                         forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>                         Sing n                         -> Sing m-                           -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)                       lambda n m                         = applySing                             (singFun1 (Proxy :: Proxy SuccSym0) SSucc)                             (applySing                                (applySing-                                  (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+)) n)+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)                                x)                     in lambda sN sM               in                 applySing                   (applySing-                     (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+)) x)+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) x)                   (applySing                      (singFun1 (Proxy :: Proxy SuccSym0) SSucc)                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))@@ -766,17 +756,17 @@           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo11Sym0 x)           lambda x             = let-                sZ :: Sing (Let_0123456789ZSym1 x)+                sZ :: Sing (Let0123456789ZSym1 x)                 (%:+) ::                   forall t t.                   Sing t-                  -> Sing t -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) t) t)+                  -> Sing t -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t)                 sZ = x                 (%:+) SZero sM                   = let                       lambda ::                         forall m. (t ~ ZeroSym0, t ~ m) =>-                        Sing m -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) ZeroSym0) m)+                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)                       lambda m = m                     in lambda sM                 (%:+) (SSucc sN) sM@@ -785,19 +775,19 @@                         forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>                         Sing n                         -> Sing m-                           -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)                       lambda n m                         = applySing                             (singFun1 (Proxy :: Proxy SuccSym0) SSucc)                             (applySing                                (applySing-                                  (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+)) n)+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)                                m)                     in lambda sN sM               in                 applySing                   (applySing-                     (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+))+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+))                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))                   sZ         in lambda sX@@ -809,12 +799,12 @@                 (%:+) ::                   forall t t.                   Sing t-                  -> Sing t -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) t) t)+                  -> Sing t -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) t) t)                 (%:+) SZero sM                   = let                       lambda ::                         forall m. (t ~ ZeroSym0, t ~ m) =>-                        Sing m -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) ZeroSym0) m)+                        Sing m -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) ZeroSym0) m)                       lambda m = m                     in lambda sM                 (%:+) (SSucc sN) sM@@ -823,19 +813,19 @@                         forall n m. (t ~ Apply SuccSym0 n, t ~ m) =>                         Sing n                         -> Sing m-                           -> Sing (Apply (Apply (Let_0123456789:+Sym1 x) (Apply SuccSym0 n)) m)+                           -> Sing (Apply (Apply ((:<<<%%%%%%%%%%:+$$) x) (Apply SuccSym0 n)) m)                       lambda n m                         = applySing                             (singFun1 (Proxy :: Proxy SuccSym0) SSucc)                             (applySing                                (applySing-                                  (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+)) n)+                                  (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+)) n)                                m)                     in lambda sN sM               in                 applySing                   (applySing-                     (singFun2 (Proxy :: Proxy (Let_0123456789:+Sym1 x)) (%:+))+                     (singFun2 (Proxy :: Proxy ((:<<<%%%%%%%%%%:+$$) x)) (%:+))                      (applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero))                   x         in lambda sX@@ -844,13 +834,13 @@           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo9Sym0 x)           lambda x             = let-                sZ :: forall t. Sing t -> Sing (Apply (Let_0123456789ZSym1 x) t)+                sZ :: forall t. Sing t -> Sing (Apply (Let0123456789ZSym1 x) t)                 sZ sA_0123456789                   = let                       lambda ::                         forall a_0123456789. t ~ a_0123456789 =>                         Sing a_0123456789-                        -> Sing (Apply (Let_0123456789ZSym1 x) a_0123456789)+                        -> Sing (Apply (Let0123456789ZSym1 x) a_0123456789)                       lambda a_0123456789                         = applySing                             (singFun1@@ -867,14 +857,14 @@                             a_0123456789                     in lambda sA_0123456789               in-                applySing (singFun1 (Proxy :: Proxy (Let_0123456789ZSym1 x)) sZ) x+                applySing (singFun1 (Proxy :: Proxy (Let0123456789ZSym1 x)) sZ) x         in lambda sX     sFoo8 sX       = let           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo8Sym0 x)           lambda x             = let-                sZ :: Sing (Let_0123456789ZSym1 x)+                sZ :: Sing (Let0123456789ZSym1 x)                 sZ                   = applySing                       (singFun1@@ -894,7 +884,7 @@           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo7Sym0 x)           lambda x             = let-                sX :: Sing (Let_0123456789XSym1 x)+                sX :: Sing (Let0123456789XSym1 x)                 sX = SZero               in sX         in lambda sX@@ -903,18 +893,17 @@           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo6Sym0 x)           lambda x             = let-                sF :: forall t. Sing t -> Sing (Apply (Let_0123456789FSym1 x) t)+                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)                 sF sY                   = let                       lambda ::-                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)+                        forall y. t ~ y => Sing y -> Sing (Apply (Let0123456789FSym1 x) y)                       lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y                     in lambda sY in               let-                sZ :: Sing (Let_0123456789ZSym1 x)+                sZ :: Sing (Let0123456789ZSym1 x)                 sZ-                  = applySing-                      (singFun1 (Proxy :: Proxy (Let_0123456789FSym1 x)) sF) x+                  = applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x               in sZ         in lambda sX     sFoo5 sX@@ -922,48 +911,48 @@           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo5Sym0 x)           lambda x             = let-                sF :: forall t. Sing t -> Sing (Apply (Let_0123456789FSym1 x) t)+                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)                 sF sY                   = let                       lambda ::-                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)+                        forall y. t ~ y => Sing y -> Sing (Apply (Let0123456789FSym1 x) y)                       lambda y                         = let-                            sZ :: Sing (Let_0123456789ZSym2 x y)+                            sZ :: Sing (Let0123456789ZSym2 x y)                             sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y                           in applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sZ                     in lambda sY               in-                applySing (singFun1 (Proxy :: Proxy (Let_0123456789FSym1 x)) sF) x+                applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x         in lambda sX     sFoo4 sX       = let           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo4Sym0 x)           lambda x             = let-                sF :: forall t. Sing t -> Sing (Apply (Let_0123456789FSym1 x) t)+                sF :: forall t. Sing t -> Sing (Apply (Let0123456789FSym1 x) t)                 sF sY                   = let                       lambda ::-                        forall y. t ~ y => Sing y -> Sing (Apply (Let_0123456789FSym1 x) y)+                        forall y. t ~ y => Sing y -> Sing (Apply (Let0123456789FSym1 x) y)                       lambda y = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) y                     in lambda sY               in-                applySing (singFun1 (Proxy :: Proxy (Let_0123456789FSym1 x)) sF) x+                applySing (singFun1 (Proxy :: Proxy (Let0123456789FSym1 x)) sF) x         in lambda sX     sFoo3 sX       = let           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo3Sym0 x)           lambda x             = let-                sY :: Sing (Let_0123456789YSym1 x)+                sY :: Sing (Let0123456789YSym1 x)                 sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) x               in sY         in lambda sX     sFoo2       = let-          sY :: Sing Let_0123456789YSym0-          sZ :: Sing Let_0123456789ZSym0+          sY :: Sing Let0123456789YSym0+          sZ :: Sing Let0123456789ZSym0           sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero           sZ = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) sY         in sZ@@ -972,7 +961,7 @@           lambda :: forall x. t ~ x => Sing x -> Sing (Apply Foo1Sym0 x)           lambda x             = let-                sY :: Sing (Let_0123456789YSym1 x)+                sY :: Sing (Let0123456789YSym1 x)                 sY = applySing (singFun1 (Proxy :: Proxy SuccSym0) SSucc) SZero               in sY         in lambda sX

@@ -126,44 +126,43 @@     foo1 (x, y) = \ _ -> x y     foo2 :: forall a b. (# a, b #) -> a     foo2 t@(# x, y #) = case t of { (# a, b #) -> \ _ -> a b }-    type Let_0123456789TSym2 t t = Let_0123456789T t t-    instance SuppressUnusedWarnings Let_0123456789TSym1 where+    type Let0123456789TSym2 t t = Let0123456789T t t+    instance SuppressUnusedWarnings Let0123456789TSym1 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789TSym1KindInference GHC.Tuple.())-    data Let_0123456789TSym1 l l-      = forall arg. KindOf (Apply (Let_0123456789TSym1 l) arg) ~ KindOf (Let_0123456789TSym2 l arg) =>-        Let_0123456789TSym1KindInference-    type instance Apply (Let_0123456789TSym1 l) l = Let_0123456789TSym2 l l-    instance SuppressUnusedWarnings Let_0123456789TSym0 where+        = snd (GHC.Tuple.(,) Let0123456789TSym1KindInference GHC.Tuple.())+    data Let0123456789TSym1 l l+      = forall arg. KindOf (Apply (Let0123456789TSym1 l) arg) ~ KindOf (Let0123456789TSym2 l arg) =>+        Let0123456789TSym1KindInference+    type instance Apply (Let0123456789TSym1 l) l = Let0123456789TSym2 l l+    instance SuppressUnusedWarnings Let0123456789TSym0 where       suppressUnusedWarnings _-        = snd (GHC.Tuple.(,) Let_0123456789TSym0KindInference GHC.Tuple.())-    data Let_0123456789TSym0 l-      = forall arg. KindOf (Apply Let_0123456789TSym0 arg) ~ KindOf (Let_0123456789TSym1 arg) =>-        Let_0123456789TSym0KindInference-    type instance Apply Let_0123456789TSym0 l = Let_0123456789TSym1 l-    type Let_0123456789T x y = Apply (Apply Tuple2Sym0 x) y-    type Let_0123456789Scrutinee_0123456789Sym2 t t =-        Let_0123456789Scrutinee_0123456789 t t-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym1 where+        = snd (GHC.Tuple.(,) Let0123456789TSym0KindInference GHC.Tuple.())+    data Let0123456789TSym0 l+      = forall arg. KindOf (Apply Let0123456789TSym0 arg) ~ KindOf (Let0123456789TSym1 arg) =>+        Let0123456789TSym0KindInference+    type instance Apply Let0123456789TSym0 l = Let0123456789TSym1 l+    type Let0123456789T x y = Apply (Apply Tuple2Sym0 x) y+    type Let0123456789Scrutinee_0123456789Sym2 t t =+        Let0123456789Scrutinee_0123456789 t t+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym1 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym1 l l-      = forall arg. KindOf (Apply (Let_0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym2 l arg) =>-        Let_0123456789Scrutinee_0123456789Sym1KindInference-    type instance Apply (Let_0123456789Scrutinee_0123456789Sym1 l) l = Let_0123456789Scrutinee_0123456789Sym2 l l-    instance SuppressUnusedWarnings Let_0123456789Scrutinee_0123456789Sym0 where+               Let0123456789Scrutinee_0123456789Sym1KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym1 l l+      = forall arg. KindOf (Apply (Let0123456789Scrutinee_0123456789Sym1 l) arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym2 l arg) =>+        Let0123456789Scrutinee_0123456789Sym1KindInference+    type instance Apply (Let0123456789Scrutinee_0123456789Sym1 l) l = Let0123456789Scrutinee_0123456789Sym2 l l+    instance SuppressUnusedWarnings Let0123456789Scrutinee_0123456789Sym0 where       suppressUnusedWarnings _         = snd             (GHC.Tuple.(,)-               Let_0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())-    data Let_0123456789Scrutinee_0123456789Sym0 l-      = forall arg. KindOf (Apply Let_0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let_0123456789Scrutinee_0123456789Sym1 arg) =>-        Let_0123456789Scrutinee_0123456789Sym0KindInference-    type instance Apply Let_0123456789Scrutinee_0123456789Sym0 l = Let_0123456789Scrutinee_0123456789Sym1 l-    type Let_0123456789Scrutinee_0123456789 x y =-        Let_0123456789TSym2 x y+               Let0123456789Scrutinee_0123456789Sym0KindInference GHC.Tuple.())+    data Let0123456789Scrutinee_0123456789Sym0 l+      = forall arg. KindOf (Apply Let0123456789Scrutinee_0123456789Sym0 arg) ~ KindOf (Let0123456789Scrutinee_0123456789Sym1 arg) =>+        Let0123456789Scrutinee_0123456789Sym0KindInference+    type instance Apply Let0123456789Scrutinee_0123456789Sym0 l = Let0123456789Scrutinee_0123456789Sym1 l+    type Let0123456789Scrutinee_0123456789 x y = Let0123456789TSym2 x y     type family Case_0123456789 x y a b arg_0123456789 t where       Case_0123456789 x y a b arg_0123456789 z = a     type family Lambda_0123456789 x y a b t where@@ -293,7 +292,7 @@     type X_0123456789Sym0 = X_0123456789     type family Foo2 (a :: (a, b)) :: a where       Foo2 '(x,-             y) = Case_0123456789 x y (Let_0123456789Scrutinee_0123456789Sym2 x y)+             y) = Case_0123456789 x y (Let0123456789Scrutinee_0123456789Sym2 x y)     type family Foo1 (a :: (a, b)) :: a where       Foo1 '(x, y) = Apply (Apply (Apply Lambda_0123456789Sym0 x) y) y     type Lsz = (Case_0123456789 X_0123456789Sym0 :: Nat)@@ -334,13 +333,13 @@             -> Sing y -> Sing (Apply Foo2Sym0 (Apply (Apply Tuple2Sym0 x) y))           lambda x y             = let-                sT :: Sing (Let_0123456789TSym2 x y)+                sT :: Sing (Let0123456789TSym2 x y)                 sT                   = applySing                       (applySing (singFun2 (Proxy :: Proxy Tuple2Sym0) STuple2) x) y in               let                 sScrutinee_0123456789 ::-                  Sing (Let_0123456789Scrutinee_0123456789Sym2 x y)+                  Sing (Let0123456789Scrutinee_0123456789Sym2 x y)                 sScrutinee_0123456789 = sT               in                 case sScrutinee_0123456789 of {