diff --git a/.travis.yml b/.travis.yml
index c47fca70..f58bbf29 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -4,7 +4,7 @@
 #
 # For more information, see https://github.com/haskell-CI/haskell-ci
 #
-# version: 0.9.20191126
+# version: 0.9.20200125
 #
 version: ~> 1.0
 language: c
@@ -30,17 +30,13 @@ before_cache:
 jobs:
   include:
     - compiler: ghc-8.10.1
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.10.1","cabal-install-3.0"]}}
-      os: linux
-    - compiler: ghc-8.8.1
-      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.8.1","cabal-install-3.0"]}}
+      addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-8.10.1","cabal-install-3.2"]}}
       os: linux
     - compiler: ghc-head
       addons: {"apt":{"sources":[{"sourceline":"deb http://ppa.launchpad.net/hvr/ghc/ubuntu xenial main","key_url":"https://keyserver.ubuntu.com/pks/lookup?op=get&search=0x063dab2bdc0b3f9fcebc378bff3aeacef6f88286"}],"packages":["ghc-head","cabal-install-head"]}}
       os: linux
   allow_failures:
     - compiler: ghc-head
-    - compiler: ghc-8.10.1
 before_install:
   - HC=$(echo "/opt/$CC/bin/ghc" | sed 's/-/\//')
   - WITHCOMPILER="-w $HC"
@@ -53,58 +49,29 @@ before_install:
   - TOP=$(pwd)
   - "HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\\d+)\\.(\\d+)\\.(\\d+)(\\.(\\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')"
   - echo $HCNUMVER
-  - CABAL="$CABAL -vnormal+nowrap+markoutput"
+  - CABAL="$CABAL -vnormal+nowrap"
   - set -o pipefail
-  - |
-    echo 'function blue(s) { printf "\033[0;34m" s "\033[0m " }'           >> .colorful.awk
-    echo 'BEGIN { state = "output"; }'                                     >> .colorful.awk
-    echo '/^-----BEGIN CABAL OUTPUT-----$/ { state = "cabal" }'            >> .colorful.awk
-    echo '/^-----END CABAL OUTPUT-----$/ { state = "output" }'             >> .colorful.awk
-    echo '!/^(-----BEGIN CABAL OUTPUT-----|-----END CABAL OUTPUT-----)/ {' >> .colorful.awk
-    echo '  if (state == "cabal") {'                                       >> .colorful.awk
-    echo '    print blue($0)'                                              >> .colorful.awk
-    echo '  } else {'                                                      >> .colorful.awk
-    echo '    print $0'                                                    >> .colorful.awk
-    echo '  }'                                                             >> .colorful.awk
-    echo '}'                                                               >> .colorful.awk
-  - cat .colorful.awk
-  - |
-    color_cabal_output () {
-      awk -f $TOP/.colorful.awk
-    }
-  - echo text | color_cabal_output
-install:
-  - ${CABAL} --version
-  - echo "$(${HC} --version) [$(${HC} --print-project-git-commit-id 2> /dev/null || echo '?')]"
   - TEST=--enable-tests
   - BENCH=--enable-benchmarks
   - HEADHACKAGE=false
-  - if [ $HCNUMVER -ge 81000 ] ; then HEADHACKAGE=true ; fi
+  - HEADHACKAGE=true
   - rm -f $CABALHOME/config
   - |
-    echo "verbose: normal +nowrap +markoutput"                                  >> $CABALHOME/config
-    echo "remote-build-reporting: anonymous"                                    >> $CABALHOME/config
-    echo "write-ghc-environment-files: always"                                  >> $CABALHOME/config
-    echo "remote-repo-cache: $CABALHOME/packages"                               >> $CABALHOME/config
-    echo "logs-dir:          $CABALHOME/logs"                                   >> $CABALHOME/config
-    echo "world-file:        $CABALHOME/world"                                  >> $CABALHOME/config
-    echo "extra-prog-path:   $CABALHOME/bin"                                    >> $CABALHOME/config
-    echo "symlink-bindir:    $CABALHOME/bin"                                    >> $CABALHOME/config
-    echo "installdir:        $CABALHOME/bin"                                    >> $CABALHOME/config
-    echo "build-summary:     $CABALHOME/logs/build.log"                         >> $CABALHOME/config
-    echo "store-dir:         $CABALHOME/store"                                  >> $CABALHOME/config
-    echo "install-dirs user"                                                    >> $CABALHOME/config
-    echo "  prefix: $CABALHOME"                                                 >> $CABALHOME/config
-    echo "repository hackage.haskell.org"                                       >> $CABALHOME/config
-    echo "  url: http://hackage.haskell.org/"                                   >> $CABALHOME/config
-    echo "  secure: True"                                                       >> $CABALHOME/config
-    echo "  key-threshold: 3"                                                   >> $CABALHOME/config
-    echo "  root-keys:"                                                         >> $CABALHOME/config
-    echo "    fe331502606802feac15e514d9b9ea83fee8b6ffef71335479a2e68d84adc6b0" >> $CABALHOME/config
-    echo "    1ea9ba32c526d1cc91ab5e5bd364ec5e9e8cb67179a471872f6e26f0ae773d42" >> $CABALHOME/config
-    echo "    2c6c3627bd6c982990239487f1abd02e08a02e6cf16edb105a8012d444d870c3" >> $CABALHOME/config
-    echo "    0a5c7ea47cd1b15f01f5f51a33adda7e655bc0f0b0615baa8e271f4c3351e21d" >> $CABALHOME/config
-    echo "    51f0161b906011b52c6613376b1ae937670da69322113a246a09f807c62f6921" >> $CABALHOME/config
+    echo "verbose: normal +nowrap +markoutput"          >> $CABALHOME/config
+    echo "remote-build-reporting: anonymous"            >> $CABALHOME/config
+    echo "write-ghc-environment-files: always"          >> $CABALHOME/config
+    echo "remote-repo-cache: $CABALHOME/packages"       >> $CABALHOME/config
+    echo "logs-dir:          $CABALHOME/logs"           >> $CABALHOME/config
+    echo "world-file:        $CABALHOME/world"          >> $CABALHOME/config
+    echo "extra-prog-path:   $CABALHOME/bin"            >> $CABALHOME/config
+    echo "symlink-bindir:    $CABALHOME/bin"            >> $CABALHOME/config
+    echo "installdir:        $CABALHOME/bin"            >> $CABALHOME/config
+    echo "build-summary:     $CABALHOME/logs/build.log" >> $CABALHOME/config
+    echo "store-dir:         $CABALHOME/store"          >> $CABALHOME/config
+    echo "install-dirs user"                            >> $CABALHOME/config
+    echo "  prefix: $CABALHOME"                         >> $CABALHOME/config
+    echo "repository hackage.haskell.org"               >> $CABALHOME/config
+    echo "  url: http://hackage.haskell.org/"           >> $CABALHOME/config
   - |
     if $HEADHACKAGE; then
     echo "allow-newer: $($HCPKG list --simple-output | sed -E 's/([a-zA-Z-]+)-[0-9.]+/*:\1/g')" >> $CABALHOME/config
@@ -116,6 +83,9 @@ install:
     echo "              f76d08be13e9a61a377a85e2fb63f4c5435d40f8feb3e12eb05905edb8cdea89" >> $CABALHOME/config
     echo "   key-threshold: 3"                                                            >> $CABALHOME/config
     fi
+install:
+  - ${CABAL} --version
+  - echo "$(${HC} --version) [$(${HC} --print-project-git-commit-id 2> /dev/null || echo '?')]"
   - |
     echo "program-default-options"                >> $CABALHOME/config
     echo "  ghc-options: $GHCJOBS +RTS -M6G -RTS" >> $CABALHOME/config
@@ -140,14 +110,14 @@ install:
   - cat cabal.project || true
   - cat cabal.project.local || true
   - if [ -f "./configure.ac" ]; then (cd "." && autoreconf -i); fi
-  - ${CABAL} v2-freeze $WITHCOMPILER ${TEST} ${BENCH} | color_cabal_output
+  - ${CABAL} v2-freeze $WITHCOMPILER ${TEST} ${BENCH}
   - "cat cabal.project.freeze | sed -E 's/^(constraints: *| *)//' | sed 's/any.//'"
   - rm  cabal.project.freeze
-  - ${CABAL} v2-build $WITHCOMPILER ${TEST} ${BENCH} --dep -j2 all | color_cabal_output
+  - ${CABAL} v2-build $WITHCOMPILER ${TEST} ${BENCH} --dep -j2 all
 script:
   - DISTDIR=$(mktemp -d /tmp/dist-test.XXXX)
   # Packaging...
-  - ${CABAL} v2-sdist all | color_cabal_output
+  - ${CABAL} v2-sdist all
   # Unpacking...
   - mv dist-newstyle/sdist/*.tar.gz ${DISTDIR}/
   - cd ${DISTDIR} || false
@@ -173,13 +143,13 @@ script:
   - cat cabal.project.local || true
   # Building with tests and benchmarks...
   # build & run tests, build benchmarks
-  - ${CABAL} v2-build $WITHCOMPILER ${TEST} ${BENCH} all | color_cabal_output
+  - ${CABAL} v2-build $WITHCOMPILER ${TEST} ${BENCH} all
   # Testing...
-  - ${CABAL} v2-test $WITHCOMPILER ${TEST} ${BENCH} all | color_cabal_output
+  - ${CABAL} v2-test $WITHCOMPILER ${TEST} ${BENCH} all
   # cabal check...
   - (cd ${PKGDIR_singletons} && ${CABAL} -vnormal check)
   # haddock...
-  - ${CABAL} v2-haddock $WITHCOMPILER --with-haddock $HADDOCK ${TEST} ${BENCH} all | color_cabal_output
+  - ${CABAL} v2-haddock $WITHCOMPILER --with-haddock $HADDOCK ${TEST} ${BENCH} all
 
-# REGENDATA ("0.9.20191126",["--output=.travis.yml","--config=cabal.haskell-ci","cabal.project"])
+# REGENDATA ("0.9.20200125",["--output=.travis.yml","--config=cabal.haskell-ci","cabal.project"])
 # EOF
diff --git a/README.md b/README.md
index cc42dd0c..cf0bb165 100644
--- a/README.md
+++ b/README.md
@@ -40,7 +40,7 @@ knowledge of dependent types.
 Compatibility
 -------------
 
-The singletons library requires GHC 8.8.1 or greater. Any code that uses the
+The singletons library requires GHC 8.10.1 or greater. Any code that uses the
 singleton generation primitives needs to enable a long list of GHC
 extensions. This list includes, but is not necessarily limited to, the
 following:
diff --git a/cabal.haskell-ci b/cabal.haskell-ci
index 2a8d1fe9..2b4042f5 100644
--- a/cabal.haskell-ci
+++ b/cabal.haskell-ci
@@ -7,3 +7,8 @@ raw-project
   package th-desugar
     tests:      False
     benchmarks: False
+
+-- Temporarily patch .travis.yml to require the GHC 8.10.1 build
+-- to succeed (as 8.10.1 is still pre-release, so haskell-ci allows
+-- it to fail by default)
+travis-patches: travis.yml.patch
diff --git a/singletons.cabal b/singletons.cabal
index 9be66653..9aff5d67 100644
--- a/singletons.cabal
+++ b/singletons.cabal
@@ -9,8 +9,7 @@ author:         Richard Eisenberg <rae@cs.brynmawr.edu>, Jan Stolarek <jan.stola
 maintainer:     Ryan Scott <ryan.gl.scott@gmail.com>
 bug-reports:    https://github.com/goldfirere/singletons/issues
 stability:      experimental
-tested-with:    GHC == 8.8.1
-              , GHC == 8.10.1
+tested-with:    GHC == 8.10.1
 extra-source-files: README.md, CHANGES.md, tests/README.md,
                     tests/compile-and-dump/GradingClient/*.hs,
                     tests/compile-and-dump/InsertionSort/*.hs,
@@ -47,14 +46,14 @@ source-repository head
 
 custom-setup
   setup-depends:
-    base      >= 4.13 && < 4.15,
-    Cabal     >= 2.5 && < 3.3,
+    base      >= 4.14 && < 4.15,
+    Cabal     >= 3.2 && < 3.3,
     directory >= 1,
     filepath  >= 1.3
 
 library
   hs-source-dirs:     src
-  build-depends:      base >= 4.13 && < 4.15,
+  build-depends:      base >= 4.14 && < 4.15,
                       mtl >= 2.2.1,
                       ghc-boot-th,
                       template-haskell,
@@ -155,7 +154,7 @@ test-suite singletons-test-suite
                       ByHand2
                       SingletonsTestSuiteUtils
 
-  build-depends:      base >= 4.13 && < 4.15,
+  build-depends:      base >= 4.14 && < 4.15,
                       bytestring >= 0.10.9,
                       deepseq >= 1.4.4,
                       filepath >= 1.3,
diff --git a/src/Data/Singletons/Deriving/Infer.hs b/src/Data/Singletons/Deriving/Infer.hs
index 1428406d..cf65a97e 100644
--- a/src/Data/Singletons/Deriving/Infer.hs
+++ b/src/Data/Singletons/Deriving/Infer.hs
@@ -19,7 +19,7 @@ import Language.Haskell.TH.Desugar
 import Language.Haskell.TH.Syntax
 import Data.Singletons.Deriving.Util
 import Data.Singletons.Util
-import Data.List
+import Data.List (nub)
 
 -- @inferConstraints cls inst_ty cons@ infers the instance context for a
 -- derived type class instance of @cls@ for @inst_ty@, using the constructors
diff --git a/src/Data/Singletons/Deriving/Util.hs b/src/Data/Singletons/Deriving/Util.hs
index 8528df4f..f16a503c 100644
--- a/src/Data/Singletons/Deriving/Util.hs
+++ b/src/Data/Singletons/Deriving/Util.hs
@@ -15,7 +15,7 @@
 module Data.Singletons.Deriving.Util where
 
 import Control.Monad
-import Data.List
+import qualified Data.List as List
 import Data.Singletons.Names
 import Data.Singletons.Syntax
 import Data.Singletons.Util
@@ -213,7 +213,7 @@ functorLikeValidityChecks allowConstrainedLastTyVar (DataDecl n data_tvbs cons)
       , (_, last_res_ty_arg) <- snocView $ filterDTANormals res_ty_args
       , Just last_tv <- getDVarTName_maybe last_res_ty_arg
       = do ex_tvbs <- conExistentialTvbs (foldTypeTvbs (DConT n) data_tvbs) con
-           let univ_tvb_names = map extractTvbName con_tvbs \\ map extractTvbName ex_tvbs
+           let univ_tvb_names = map extractTvbName con_tvbs List.\\ map extractTvbName ex_tvbs
            if last_tv `elem` univ_tvb_names
                 && last_tv `OSet.notMember` foldMap fvDType con_theta
               then pure ()
diff --git a/src/Data/Singletons/Prelude/List/Internal/Disambiguation.hs b/src/Data/Singletons/Prelude/List/Internal/Disambiguation.hs
index cc2a85fd..77ce5d34 100644
--- a/src/Data/Singletons/Prelude/List/Internal/Disambiguation.hs
+++ b/src/Data/Singletons/Prelude/List/Internal/Disambiguation.hs
@@ -25,7 +25,8 @@ import Data.Singletons.Prelude.List.Internal
 import Data.Singletons.Prelude.Num
 import Data.Singletons.Prelude.Ord
 import Data.Singletons.Prelude.Eq
-import Data.List
+import Data.List ( foldl', inits, insert, intersperse, isPrefixOf
+                 , nubBy, partition, sort, sortBy, tails, transpose )
 import GHC.TypeLits
 
 -- singletons doesn't support qualified names :(
diff --git a/src/Data/Singletons/Single.hs b/src/Data/Singletons/Single.hs
index 3b1872dc..09507096 100644
--- a/src/Data/Singletons/Single.hs
+++ b/src/Data/Singletons/Single.hs
@@ -44,7 +44,7 @@ import Data.Maybe
 import qualified Data.Set as Set
 import Control.Monad
 import Control.Monad.Trans.Class
-import Data.List
+import Data.List (unzip6, zipWith4)
 import qualified GHC.LanguageExtensions.Type as LangExt
 
 {-
diff --git a/src/Data/Singletons/Single/Defun.hs b/src/Data/Singletons/Single/Defun.hs
index f4b17798..002d7cc8 100644
--- a/src/Data/Singletons/Single/Defun.hs
+++ b/src/Data/Singletons/Single/Defun.hs
@@ -14,7 +14,7 @@
 module Data.Singletons.Single.Defun (singDefuns) where
 
 import Control.Monad
-import Data.List
+import Data.Foldable
 import Data.Singletons.Names
 import Data.Singletons.Promote.Defun
 import Data.Singletons.Single.Monad
diff --git a/src/Data/Singletons/Single/Monad.hs b/src/Data/Singletons/Single/Monad.hs
index 40a1f7eb..ad0290d7 100644
--- a/src/Data/Singletons/Single/Monad.hs
+++ b/src/Data/Singletons/Single/Monad.hs
@@ -8,7 +8,7 @@ This file defines the SgM monad and its operations, for use during singling.
 The SgM monad allows reading from a SgEnv environment and is wrapped around a Q.
 -}
 
-{-# LANGUAGE GeneralizedNewtypeDeriving, ParallelListComp, TemplateHaskell, CPP #-}
+{-# LANGUAGE GeneralizedNewtypeDeriving, ParallelListComp, TemplateHaskell #-}
 
 module Data.Singletons.Single.Monad (
   SgM, bindLets, bindContext, askContext, lookupVarE, lookupConE,
@@ -78,9 +78,7 @@ instance Quasi SgM where
   qAddForeignFilePath = liftSgM `comp2` qAddForeignFilePath
   qAddTempFile        = liftSgM `comp1` qAddTempFile
   qAddCorePlugin      = liftSgM `comp1` qAddCorePlugin
-#if MIN_VERSION_template_haskell(2,16,0)
   qReifyType          = liftSgM `comp1` qReifyType
-#endif
 
   qRecover (SgM handler) (SgM body) = do
     env <- ask
diff --git a/src/Data/Singletons/Single/Type.hs b/src/Data/Singletons/Single/Type.hs
index de2dce9c..4e8e5c4c 100644
--- a/src/Data/Singletons/Single/Type.hs
+++ b/src/Data/Singletons/Single/Type.hs
@@ -19,7 +19,7 @@ import Data.Singletons.Util
 import Control.Monad
 import Data.Foldable
 import Data.Function
-import Data.List
+import Data.List (deleteFirstsBy)
 
 singType :: OSet Name      -- the set of bound kind variables in this scope
                            -- see Note [Explicitly binding kind variables]
diff --git a/src/Data/Singletons/Util.hs b/src/Data/Singletons/Util.hs
index 414da99e..8115f896 100644
--- a/src/Data/Singletons/Util.hs
+++ b/src/Data/Singletons/Util.hs
@@ -11,7 +11,7 @@ Users of the package should not need to consult this file.
              TemplateHaskell, GeneralizedNewtypeDeriving,
              MultiParamTypeClasses, UndecidableInstances, MagicHash,
              LambdaCase, NoMonomorphismRestriction, ScopedTypeVariables,
-             FlexibleContexts, CPP #-}
+             FlexibleContexts #-}
 
 module Data.Singletons.Util where
 
@@ -497,9 +497,7 @@ instance (Quasi q, Monoid m) => Quasi (QWithAux m q) where
   qAddForeignFilePath = lift `comp2` qAddForeignFilePath
   qAddTempFile        = lift `comp1` qAddTempFile
   qAddCorePlugin      = lift `comp1` qAddCorePlugin
-#if MIN_VERSION_template_haskell(2,16,0)
   qReifyType          = lift `comp1` qReifyType
-#endif
 
   qRecover exp handler = do
     (result, aux) <- lift $ qRecover (evalForPair exp) (evalForPair handler)
diff --git a/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden b/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden
index 0081abac..857db247 100644
--- a/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden
+++ b/tests/compile-and-dump/Singletons/FunctorLikeDeriving.golden
@@ -169,16 +169,16 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
     type Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 =
         Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type family Fmap_0123456789876543210 (a :: (~>) a0123456789876543210 b0123456789876543210) (a :: T x a0123456789876543210) :: T x b0123456789876543210 where
+    type family Fmap_0123456789876543210 (a :: (~>) a b) (a :: T x a) :: T x b where
       Fmap_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (Apply (Apply MkT1Sym0 (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply _f_0123456789876543210 a_0123456789876543210)) (Apply (Apply FmapSym0 _f_0123456789876543210) a_0123456789876543210)) (Apply (Apply FmapSym0 (Apply FmapSym0 _f_0123456789876543210)) a_0123456789876543210)
       Fmap_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply MkT2Sym0 (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210)
     instance SuppressUnusedWarnings Fmap_0123456789876543210Sym0 where
       suppressUnusedWarnings
         = snd (((,) Fmap_0123456789876543210Sym0KindInference) ())
-    data Fmap_0123456789876543210Sym0 :: forall a01234567898765432100123456789876543210
-                                                b01234567898765432100123456789876543210
+    data Fmap_0123456789876543210Sym0 :: forall a0123456789876543210
+                                                b0123456789876543210
                                                 x0123456789876543210.
-                                         (~>) ((~>) a01234567898765432100123456789876543210 b01234567898765432100123456789876543210) ((~>) (T x0123456789876543210 a01234567898765432100123456789876543210) (T x0123456789876543210 b01234567898765432100123456789876543210))
+                                         (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) (T x0123456789876543210 a0123456789876543210) (T x0123456789876543210 b0123456789876543210))
       where
         Fmap_0123456789876543210Sym0KindInference :: forall a0123456789876543210
                                                             arg. SameKind (Apply Fmap_0123456789876543210Sym0 arg) (Fmap_0123456789876543210Sym1 arg) =>
@@ -187,15 +187,15 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance SuppressUnusedWarnings (Fmap_0123456789876543210Sym1 a0123456789876543210) where
       suppressUnusedWarnings
         = snd (((,) Fmap_0123456789876543210Sym1KindInference) ())
-    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 b01234567898765432100123456789876543210) :: forall x0123456789876543210.
-                                                                                                                                                        (~>) (T x0123456789876543210 a01234567898765432100123456789876543210) (T x0123456789876543210 b01234567898765432100123456789876543210)
+    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: forall x0123456789876543210.
+                                                                                                                  (~>) (T x0123456789876543210 a0123456789876543210) (T x0123456789876543210 b0123456789876543210)
       where
         Fmap_0123456789876543210Sym1KindInference :: forall a0123456789876543210
                                                             a0123456789876543210
                                                             arg. SameKind (Apply (Fmap_0123456789876543210Sym1 a0123456789876543210) arg) (Fmap_0123456789876543210Sym2 a0123456789876543210 arg) =>
                                                      Fmap_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
     type instance Apply (Fmap_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Fmap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    type Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 b01234567898765432100123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a01234567898765432100123456789876543210) =
+    type Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a0123456789876543210) =
         Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210
     type family Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 where
       Lambda_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n_0123456789876543210 = n_0123456789876543210
@@ -516,16 +516,16 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     type instance Apply (Lambda_0123456789876543210Sym2 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210) n_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
     type Lambda_0123456789876543210Sym3 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210 =
         Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n_01234567898765432100123456789876543210
-    type family FoldMap_0123456789876543210 (a :: (~>) a0123456789876543210 m0123456789876543210) (a :: T x a0123456789876543210) :: m0123456789876543210 where
+    type family FoldMap_0123456789876543210 (a :: (~>) a m) (a :: T x a) :: m where
       FoldMap_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply MappendSym0 (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210)) (Apply (Apply MappendSym0 (Apply _f_0123456789876543210 a_0123456789876543210)) (Apply (Apply MappendSym0 (Apply (Apply FoldMapSym0 _f_0123456789876543210) a_0123456789876543210)) (Apply (Apply FoldMapSym0 (Apply FoldMapSym0 _f_0123456789876543210)) a_0123456789876543210)))
       FoldMap_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) a_0123456789876543210) a_0123456789876543210
     instance SuppressUnusedWarnings FoldMap_0123456789876543210Sym0 where
       suppressUnusedWarnings
         = snd (((,) FoldMap_0123456789876543210Sym0KindInference) ())
-    data FoldMap_0123456789876543210Sym0 :: forall a01234567898765432100123456789876543210
-                                                   m01234567898765432100123456789876543210
+    data FoldMap_0123456789876543210Sym0 :: forall a0123456789876543210
+                                                   m0123456789876543210
                                                    x0123456789876543210.
-                                            (~>) ((~>) a01234567898765432100123456789876543210 m01234567898765432100123456789876543210) ((~>) (T x0123456789876543210 a01234567898765432100123456789876543210) m01234567898765432100123456789876543210)
+                                            (~>) ((~>) a0123456789876543210 m0123456789876543210) ((~>) (T x0123456789876543210 a0123456789876543210) m0123456789876543210)
       where
         FoldMap_0123456789876543210Sym0KindInference :: forall a0123456789876543210
                                                                arg. SameKind (Apply FoldMap_0123456789876543210Sym0 arg) (FoldMap_0123456789876543210Sym1 arg) =>
@@ -534,15 +534,15 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance SuppressUnusedWarnings (FoldMap_0123456789876543210Sym1 a0123456789876543210) where
       suppressUnusedWarnings
         = snd (((,) FoldMap_0123456789876543210Sym1KindInference) ())
-    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 m01234567898765432100123456789876543210) :: forall x0123456789876543210.
-                                                                                                                                                           (~>) (T x0123456789876543210 a01234567898765432100123456789876543210) m01234567898765432100123456789876543210
+    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) :: forall x0123456789876543210.
+                                                                                                                     (~>) (T x0123456789876543210 a0123456789876543210) m0123456789876543210
       where
         FoldMap_0123456789876543210Sym1KindInference :: forall a0123456789876543210
                                                                a0123456789876543210
                                                                arg. SameKind (Apply (FoldMap_0123456789876543210Sym1 a0123456789876543210) arg) (FoldMap_0123456789876543210Sym2 a0123456789876543210 arg) =>
                                                         FoldMap_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
     type instance Apply (FoldMap_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = FoldMap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    type FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 m01234567898765432100123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a01234567898765432100123456789876543210) =
+    type FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a0123456789876543210) =
         FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210
     type family Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 where
       Lambda_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 n1_0123456789876543210 n2_0123456789876543210 = n2_0123456789876543210
@@ -1054,16 +1054,16 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     type instance Apply (Lambda_0123456789876543210Sym4 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210) n2_01234567898765432100123456789876543210 = Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
     type Lambda_0123456789876543210Sym5 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210 =
         Lambda_0123456789876543210 _f_01234567898765432100123456789876543210 _z_01234567898765432100123456789876543210 a_01234567898765432100123456789876543210 n1_01234567898765432100123456789876543210 n2_01234567898765432100123456789876543210
-    type family Foldr_0123456789876543210 (a :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (a :: b0123456789876543210) (a :: T x a0123456789876543210) :: b0123456789876543210 where
+    type family Foldr_0123456789876543210 (a :: (~>) a ((~>) b b)) (a :: b) (a :: T x a) :: b where
       Foldr_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) (Apply (Apply _f_0123456789876543210 a_0123456789876543210) (Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) (Apply (Apply (Apply (Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) a_0123456789876543210) _z_0123456789876543210)))
       Foldr_0123456789876543210 _f_0123456789876543210 _z_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply (Apply (Apply (Apply Lambda_0123456789876543210Sym0 _f_0123456789876543210) _z_0123456789876543210) a_0123456789876543210) a_0123456789876543210) _z_0123456789876543210
     instance SuppressUnusedWarnings Foldr_0123456789876543210Sym0 where
       suppressUnusedWarnings
         = snd (((,) Foldr_0123456789876543210Sym0KindInference) ())
-    data Foldr_0123456789876543210Sym0 :: forall a01234567898765432100123456789876543210
-                                                 b01234567898765432100123456789876543210
+    data Foldr_0123456789876543210Sym0 :: forall a0123456789876543210
+                                                 b0123456789876543210
                                                  x0123456789876543210.
-                                          (~>) ((~>) a01234567898765432100123456789876543210 ((~>) b01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) ((~>) b01234567898765432100123456789876543210 ((~>) (T x0123456789876543210 a01234567898765432100123456789876543210) b01234567898765432100123456789876543210))
+                                          (~>) ((~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) ((~>) b0123456789876543210 ((~>) (T x0123456789876543210 a0123456789876543210) b0123456789876543210))
       where
         Foldr_0123456789876543210Sym0KindInference :: forall a0123456789876543210
                                                              arg. SameKind (Apply Foldr_0123456789876543210Sym0 arg) (Foldr_0123456789876543210Sym1 arg) =>
@@ -1072,8 +1072,8 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance SuppressUnusedWarnings (Foldr_0123456789876543210Sym1 a0123456789876543210) where
       suppressUnusedWarnings
         = snd (((,) Foldr_0123456789876543210Sym1KindInference) ())
-    data Foldr_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 ((~>) b01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) :: forall x0123456789876543210.
-                                                                                                                                                                                                        (~>) b01234567898765432100123456789876543210 ((~>) (T x0123456789876543210 a01234567898765432100123456789876543210) b01234567898765432100123456789876543210)
+    data Foldr_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) :: forall x0123456789876543210.
+                                                                                                                                               (~>) b0123456789876543210 ((~>) (T x0123456789876543210 a0123456789876543210) b0123456789876543210)
       where
         Foldr_0123456789876543210Sym1KindInference :: forall a0123456789876543210
                                                              a0123456789876543210
@@ -1083,8 +1083,8 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance SuppressUnusedWarnings (Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) where
       suppressUnusedWarnings
         = snd (((,) Foldr_0123456789876543210Sym2KindInference) ())
-    data Foldr_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 ((~>) b01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) (a0123456789876543210 :: b01234567898765432100123456789876543210) :: forall x0123456789876543210.
-                                                                                                                                                                                                                                                                          (~>) (T x0123456789876543210 a01234567898765432100123456789876543210) b01234567898765432100123456789876543210
+    data Foldr_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: b0123456789876543210) :: forall x0123456789876543210.
+                                                                                                                                                                                              (~>) (T x0123456789876543210 a0123456789876543210) b0123456789876543210
       where
         Foldr_0123456789876543210Sym2KindInference :: forall a0123456789876543210
                                                              a0123456789876543210
@@ -1092,22 +1092,22 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
                                                              arg. SameKind (Apply (Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) arg) (Foldr_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 arg) =>
                                                       Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210 a0123456789876543210
     type instance Apply (Foldr_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210) a0123456789876543210 = Foldr_0123456789876543210Sym3 a0123456789876543210 a0123456789876543210 a0123456789876543210
-    type Foldr_0123456789876543210Sym3 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 ((~>) b01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) (a0123456789876543210 :: b01234567898765432100123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a01234567898765432100123456789876543210) =
+    type Foldr_0123456789876543210Sym3 (a0123456789876543210 :: (~>) a0123456789876543210 ((~>) b0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: b0123456789876543210) (a0123456789876543210 :: T x0123456789876543210 a0123456789876543210) =
         Foldr_0123456789876543210 a0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PFoldable (T x) where
       type FoldMap a a = Apply (Apply FoldMap_0123456789876543210Sym0 a) a
       type Foldr a a a = Apply (Apply (Apply Foldr_0123456789876543210Sym0 a) a) a
-    type family Traverse_0123456789876543210 (a :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) (a :: T x a0123456789876543210) :: f0123456789876543210 (T x b0123456789876543210) where
+    type family Traverse_0123456789876543210 (a :: (~>) a (f b)) (a :: T x a) :: f (T x b) where
       Traverse_0123456789876543210 _f_0123456789876543210 (MkT1 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210 a_0123456789876543210) = Apply (Apply (<*>@#@$) (Apply (Apply (<*>@#@$) (Apply (Apply (Apply LiftA2Sym0 MkT1Sym0) (Apply PureSym0 a_0123456789876543210)) (Apply _f_0123456789876543210 a_0123456789876543210))) (Apply (Apply TraverseSym0 _f_0123456789876543210) a_0123456789876543210))) (Apply (Apply TraverseSym0 (Apply TraverseSym0 _f_0123456789876543210)) a_0123456789876543210)
       Traverse_0123456789876543210 _f_0123456789876543210 (MkT2 a_0123456789876543210) = Apply (Apply FmapSym0 MkT2Sym0) (Apply PureSym0 a_0123456789876543210)
     instance SuppressUnusedWarnings Traverse_0123456789876543210Sym0 where
       suppressUnusedWarnings
         = snd (((,) Traverse_0123456789876543210Sym0KindInference) ())
-    data Traverse_0123456789876543210Sym0 :: forall a01234567898765432100123456789876543210
-                                                    f01234567898765432100123456789876543210
-                                                    b01234567898765432100123456789876543210
+    data Traverse_0123456789876543210Sym0 :: forall a0123456789876543210
+                                                    f0123456789876543210
+                                                    b0123456789876543210
                                                     x0123456789876543210.
-                                             (~>) ((~>) a01234567898765432100123456789876543210 (f01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) ((~>) (T x0123456789876543210 a01234567898765432100123456789876543210) (f01234567898765432100123456789876543210 (T x0123456789876543210 b01234567898765432100123456789876543210)))
+                                             (~>) ((~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) ((~>) (T x0123456789876543210 a0123456789876543210) (f0123456789876543210 (T x0123456789876543210 b0123456789876543210)))
       where
         Traverse_0123456789876543210Sym0KindInference :: forall a0123456789876543210
                                                                 arg. SameKind (Apply Traverse_0123456789876543210Sym0 arg) (Traverse_0123456789876543210Sym1 arg) =>
@@ -1116,27 +1116,27 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance SuppressUnusedWarnings (Traverse_0123456789876543210Sym1 a0123456789876543210) where
       suppressUnusedWarnings
         = snd (((,) Traverse_0123456789876543210Sym1KindInference) ())
-    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 (f01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) :: forall x0123456789876543210.
-                                                                                                                                                                                                      (~>) (T x0123456789876543210 a01234567898765432100123456789876543210) (f01234567898765432100123456789876543210 (T x0123456789876543210 b01234567898765432100123456789876543210))
+    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) :: forall x0123456789876543210.
+                                                                                                                                             (~>) (T x0123456789876543210 a0123456789876543210) (f0123456789876543210 (T x0123456789876543210 b0123456789876543210))
       where
         Traverse_0123456789876543210Sym1KindInference :: forall a0123456789876543210
                                                                 a0123456789876543210
                                                                 arg. SameKind (Apply (Traverse_0123456789876543210Sym1 a0123456789876543210) arg) (Traverse_0123456789876543210Sym2 a0123456789876543210 arg) =>
                                                          Traverse_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
     type instance Apply (Traverse_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Traverse_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    type Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 (f01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) (a0123456789876543210 :: T x0123456789876543210 a01234567898765432100123456789876543210) =
+    type Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: T x0123456789876543210 a0123456789876543210) =
         Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PTraversable (T x) where
       type Traverse a a = Apply (Apply Traverse_0123456789876543210Sym0 a) a
     type family Case_0123456789876543210 v_0123456789876543210 t where
-    type family Fmap_0123456789876543210 (a :: (~>) a0123456789876543210 b0123456789876543210) (a :: Empty a0123456789876543210) :: Empty b0123456789876543210 where
+    type family Fmap_0123456789876543210 (a :: (~>) a b) (a :: Empty a) :: Empty b where
       Fmap_0123456789876543210 _ v_0123456789876543210 = Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210
     instance SuppressUnusedWarnings Fmap_0123456789876543210Sym0 where
       suppressUnusedWarnings
         = snd (((,) Fmap_0123456789876543210Sym0KindInference) ())
-    data Fmap_0123456789876543210Sym0 :: forall a01234567898765432100123456789876543210
-                                                b01234567898765432100123456789876543210.
-                                         (~>) ((~>) a01234567898765432100123456789876543210 b01234567898765432100123456789876543210) ((~>) (Empty a01234567898765432100123456789876543210) (Empty b01234567898765432100123456789876543210))
+    data Fmap_0123456789876543210Sym0 :: forall a0123456789876543210
+                                                b0123456789876543210.
+                                         (~>) ((~>) a0123456789876543210 b0123456789876543210) ((~>) (Empty a0123456789876543210) (Empty b0123456789876543210))
       where
         Fmap_0123456789876543210Sym0KindInference :: forall a0123456789876543210
                                                             arg. SameKind (Apply Fmap_0123456789876543210Sym0 arg) (Fmap_0123456789876543210Sym1 arg) =>
@@ -1145,14 +1145,14 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance SuppressUnusedWarnings (Fmap_0123456789876543210Sym1 a0123456789876543210) where
       suppressUnusedWarnings
         = snd (((,) Fmap_0123456789876543210Sym1KindInference) ())
-    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 b01234567898765432100123456789876543210) :: (~>) (Empty a01234567898765432100123456789876543210) (Empty b01234567898765432100123456789876543210)
+    data Fmap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) :: (~>) (Empty a0123456789876543210) (Empty b0123456789876543210)
       where
         Fmap_0123456789876543210Sym1KindInference :: forall a0123456789876543210
                                                             a0123456789876543210
                                                             arg. SameKind (Apply (Fmap_0123456789876543210Sym1 a0123456789876543210) arg) (Fmap_0123456789876543210Sym2 a0123456789876543210 arg) =>
                                                      Fmap_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
     type instance Apply (Fmap_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Fmap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    type Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 b01234567898765432100123456789876543210) (a0123456789876543210 :: Empty a01234567898765432100123456789876543210) =
+    type Fmap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 b0123456789876543210) (a0123456789876543210 :: Empty a0123456789876543210) =
         Fmap_0123456789876543210 a0123456789876543210 a0123456789876543210
     type family Case_0123456789876543210 v_0123456789876543210 t where
     type family TFHelper_0123456789876543210 (a :: a) (a :: Empty b) :: Empty a where
@@ -1184,14 +1184,14 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance PFunctor Empty where
       type Fmap a a = Apply (Apply Fmap_0123456789876543210Sym0 a) a
       type (<$) a a = Apply (Apply TFHelper_0123456789876543210Sym0 a) a
-    type family FoldMap_0123456789876543210 (a :: (~>) a0123456789876543210 m0123456789876543210) (a :: Empty a0123456789876543210) :: m0123456789876543210 where
+    type family FoldMap_0123456789876543210 (a :: (~>) a m) (a :: Empty a) :: m where
       FoldMap_0123456789876543210 _ _ = MemptySym0
     instance SuppressUnusedWarnings FoldMap_0123456789876543210Sym0 where
       suppressUnusedWarnings
         = snd (((,) FoldMap_0123456789876543210Sym0KindInference) ())
-    data FoldMap_0123456789876543210Sym0 :: forall a01234567898765432100123456789876543210
-                                                   m01234567898765432100123456789876543210.
-                                            (~>) ((~>) a01234567898765432100123456789876543210 m01234567898765432100123456789876543210) ((~>) (Empty a01234567898765432100123456789876543210) m01234567898765432100123456789876543210)
+    data FoldMap_0123456789876543210Sym0 :: forall a0123456789876543210
+                                                   m0123456789876543210.
+                                            (~>) ((~>) a0123456789876543210 m0123456789876543210) ((~>) (Empty a0123456789876543210) m0123456789876543210)
       where
         FoldMap_0123456789876543210Sym0KindInference :: forall a0123456789876543210
                                                                arg. SameKind (Apply FoldMap_0123456789876543210Sym0 arg) (FoldMap_0123456789876543210Sym1 arg) =>
@@ -1200,27 +1200,27 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance SuppressUnusedWarnings (FoldMap_0123456789876543210Sym1 a0123456789876543210) where
       suppressUnusedWarnings
         = snd (((,) FoldMap_0123456789876543210Sym1KindInference) ())
-    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 m01234567898765432100123456789876543210) :: (~>) (Empty a01234567898765432100123456789876543210) m01234567898765432100123456789876543210
+    data FoldMap_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) :: (~>) (Empty a0123456789876543210) m0123456789876543210
       where
         FoldMap_0123456789876543210Sym1KindInference :: forall a0123456789876543210
                                                                a0123456789876543210
                                                                arg. SameKind (Apply (FoldMap_0123456789876543210Sym1 a0123456789876543210) arg) (FoldMap_0123456789876543210Sym2 a0123456789876543210 arg) =>
                                                         FoldMap_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
     type instance Apply (FoldMap_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = FoldMap_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    type FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 m01234567898765432100123456789876543210) (a0123456789876543210 :: Empty a01234567898765432100123456789876543210) =
+    type FoldMap_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 m0123456789876543210) (a0123456789876543210 :: Empty a0123456789876543210) =
         FoldMap_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PFoldable Empty where
       type FoldMap a a = Apply (Apply FoldMap_0123456789876543210Sym0 a) a
     type family Case_0123456789876543210 v_0123456789876543210 t where
-    type family Traverse_0123456789876543210 (a :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) (a :: Empty a0123456789876543210) :: f0123456789876543210 (Empty b0123456789876543210) where
+    type family Traverse_0123456789876543210 (a :: (~>) a (f b)) (a :: Empty a) :: f (Empty b) where
       Traverse_0123456789876543210 _ v_0123456789876543210 = Apply PureSym0 (Case_0123456789876543210 v_0123456789876543210 v_0123456789876543210)
     instance SuppressUnusedWarnings Traverse_0123456789876543210Sym0 where
       suppressUnusedWarnings
         = snd (((,) Traverse_0123456789876543210Sym0KindInference) ())
-    data Traverse_0123456789876543210Sym0 :: forall a01234567898765432100123456789876543210
-                                                    f01234567898765432100123456789876543210
-                                                    b01234567898765432100123456789876543210.
-                                             (~>) ((~>) a01234567898765432100123456789876543210 (f01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) ((~>) (Empty a01234567898765432100123456789876543210) (f01234567898765432100123456789876543210 (Empty b01234567898765432100123456789876543210)))
+    data Traverse_0123456789876543210Sym0 :: forall a0123456789876543210
+                                                    f0123456789876543210
+                                                    b0123456789876543210.
+                                             (~>) ((~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) ((~>) (Empty a0123456789876543210) (f0123456789876543210 (Empty b0123456789876543210)))
       where
         Traverse_0123456789876543210Sym0KindInference :: forall a0123456789876543210
                                                                 arg. SameKind (Apply Traverse_0123456789876543210Sym0 arg) (Traverse_0123456789876543210Sym1 arg) =>
@@ -1229,14 +1229,14 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
     instance SuppressUnusedWarnings (Traverse_0123456789876543210Sym1 a0123456789876543210) where
       suppressUnusedWarnings
         = snd (((,) Traverse_0123456789876543210Sym1KindInference) ())
-    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 (f01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) :: (~>) (Empty a01234567898765432100123456789876543210) (f01234567898765432100123456789876543210 (Empty b01234567898765432100123456789876543210))
+    data Traverse_0123456789876543210Sym1 (a0123456789876543210 :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) :: (~>) (Empty a0123456789876543210) (f0123456789876543210 (Empty b0123456789876543210))
       where
         Traverse_0123456789876543210Sym1KindInference :: forall a0123456789876543210
                                                                 a0123456789876543210
                                                                 arg. SameKind (Apply (Traverse_0123456789876543210Sym1 a0123456789876543210) arg) (Traverse_0123456789876543210Sym2 a0123456789876543210 arg) =>
                                                          Traverse_0123456789876543210Sym1 a0123456789876543210 a0123456789876543210
     type instance Apply (Traverse_0123456789876543210Sym1 a0123456789876543210) a0123456789876543210 = Traverse_0123456789876543210Sym2 a0123456789876543210 a0123456789876543210
-    type Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a01234567898765432100123456789876543210 (f01234567898765432100123456789876543210 b01234567898765432100123456789876543210)) (a0123456789876543210 :: Empty a01234567898765432100123456789876543210) =
+    type Traverse_0123456789876543210Sym2 (a0123456789876543210 :: (~>) a0123456789876543210 (f0123456789876543210 b0123456789876543210)) (a0123456789876543210 :: Empty a0123456789876543210) =
         Traverse_0123456789876543210 a0123456789876543210 a0123456789876543210
     instance PTraversable Empty where
       type Traverse a a = Apply (Apply Traverse_0123456789876543210Sym0 a) a
@@ -1259,9 +1259,7 @@ Singletons/FunctorLikeDeriving.hs:(0,0)-(0,0): Splicing declarations
         = (((MkT1 (fromSing b)) (fromSing b)) (fromSing b)) (fromSing b)
       fromSing (SMkT2 b) = MkT2 (fromSing b)
       toSing
-        (MkT1 (b :: Demote x)
-              (b :: Demote a)
-              (b :: Demote (Maybe a))
+        (MkT1 (b :: Demote x) (b :: Demote a) (b :: Demote (Maybe a))
               (b :: Demote (Maybe (Maybe a))))
         = case
               ((((,,,) (toSing b :: SomeSing x)) (toSing b :: SomeSing a))
diff --git a/tests/compile-and-dump/Singletons/T183.golden b/tests/compile-and-dump/Singletons/T183.golden
index 02167e3d..7f863d6e 100644
--- a/tests/compile-and-dump/Singletons/T183.golden
+++ b/tests/compile-and-dump/Singletons/T183.golden
@@ -432,8 +432,7 @@ Singletons/T183.hs:(0,0)-(0,0): Splicing declarations
             (((,,) (sX :: Sing x)) (SJust (sX :: Sing x)))
               (SJust (SJust (sX :: Sing x)))
         of {
-          (,,) (_ :: Sing (x :: a))
-               (_ :: Sing ('Just (x :: a) :: Maybe a))
+          (,,) (_ :: Sing (x :: a)) (_ :: Sing ('Just (x :: a) :: Maybe a))
                (_ :: Sing ('Just ('Just (x :: a) :: Maybe a) :: Maybe (Maybe a)))
             -> (applySing ((singFun1 @JustSym0) SJust))
                  ((applySing ((singFun1 @JustSym0) SJust)) (sX :: Sing (x :: a)) ::
diff --git a/travis.yml.patch b/travis.yml.patch
new file mode 100644
index 00000000..edc21cde
--- /dev/null
+++ b/travis.yml.patch
@@ -0,0 +1,12 @@
+diff --git a/.travis.yml b/.travis.yml
+index 24ea25d..e6ecb3b 100644
+--- a/.travis.yml
++++ b/.travis.yml
+@@ -37,7 +37,6 @@ jobs:
+       os: linux
+   allow_failures:
+     - compiler: ghc-head
+-    - compiler: ghc-8.10.1
+ before_install:
+   - HC=$(echo "/opt/$CC/bin/ghc" | sed 's/-/\//')
+   - WITHCOMPILER="-w $HC"