Kill varSetElemsWellScoped in quantifyTyVars
authorBartosz Nitka <niteria@gmail.com>
Tue, 26 Apr 2016 12:58:24 +0000 (05:58 -0700)
committerBartosz Nitka <niteria@gmail.com>
Tue, 26 Apr 2016 13:40:04 +0000 (06:40 -0700)
varSetElemsWellScoped introduces unnecessary non-determinism in
inferred type signatures.
Removing this instance required changing the representation of
TcDepVars to use deterministic sets.
This is the last occurence of varSetElemsWellScoped, allowing me to
finally remove it.

Test Plan:
./validate
I will update the expected outputs when commiting, some reordering
of type variables in types is expected.

Reviewers: goldfire, simonpj, austin, bgamari

Reviewed By: simonpj

Subscribers: thomie, simonmar

Differential Revision: https://phabricator.haskell.org/D2135

GHC Trac Issues: #4012

59 files changed:
compiler/basicTypes/VarSet.hs
compiler/typecheck/TcHsType.hs
compiler/typecheck/TcMType.hs
compiler/typecheck/TcSimplify.hs
compiler/typecheck/TcType.hs
compiler/types/Type.hs
compiler/types/Type.hs-boot
compiler/utils/UniqDFM.hs
compiler/utils/UniqDSet.hs
compiler/utils/UniqFM.hs
testsuite/tests/ado/ado004.stderr
testsuite/tests/dependent/should_fail/T11334b.stderr
testsuite/tests/driver/werror.stderr
testsuite/tests/gadt/gadt13.stderr
testsuite/tests/gadt/gadt7.stderr
testsuite/tests/ghci.debugger/scripts/break026.stdout
testsuite/tests/ghci/scripts/T11524a.stdout
testsuite/tests/ghci/scripts/T6018ghcifail.stderr
testsuite/tests/ghci/scripts/T7587.stdout
testsuite/tests/ghci/scripts/T7730.stdout
testsuite/tests/ghci/scripts/T7939.stdout
testsuite/tests/ghci/scripts/T8776.stdout
testsuite/tests/indexed-types/should_compile/T3017.stderr
testsuite/tests/indexed-types/should_compile/T8889.stderr
testsuite/tests/indexed-types/should_fail/T7354.stderr
testsuite/tests/indexed-types/should_fail/T8518.stderr
testsuite/tests/module/mod71.stderr
testsuite/tests/module/mod72.stderr
testsuite/tests/parser/should_compile/read014.stderr
testsuite/tests/parser/should_fail/readFail003.stderr
testsuite/tests/partial-sigs/should_compile/ExtraConstraints3.stderr
testsuite/tests/partial-sigs/should_compile/NamedTyVar.stderr
testsuite/tests/partial-sigs/should_compile/SkipMany.stderr
testsuite/tests/partial-sigs/should_compile/T10438.stderr
testsuite/tests/partial-sigs/should_compile/UncurryNamed.stderr
testsuite/tests/partial-sigs/should_compile/WarningWildcardInstantiations.stderr
testsuite/tests/partial-sigs/should_fail/T10045.stderr
testsuite/tests/partial-sigs/should_fail/WildcardInstantiations.stderr
testsuite/tests/patsyn/should_compile/T11213.stderr
testsuite/tests/polykinds/T7438.stderr
testsuite/tests/polykinds/T7524.stderr
testsuite/tests/rename/should_fail/T2993.stderr
testsuite/tests/typecheck/should_compile/T10971a.stderr
testsuite/tests/typecheck/should_compile/tc141.stderr
testsuite/tests/typecheck/should_compile/tc168.stderr
testsuite/tests/typecheck/should_compile/tc231.stderr
testsuite/tests/typecheck/should_fail/T5853.stderr
testsuite/tests/typecheck/should_fail/T6018fail.stderr
testsuite/tests/typecheck/should_fail/T6018failclosed.stderr
testsuite/tests/typecheck/should_fail/T7453.stderr
testsuite/tests/typecheck/should_fail/T7734.stderr
testsuite/tests/typecheck/should_fail/T8142.stderr
testsuite/tests/typecheck/should_fail/T9109.stderr
testsuite/tests/typecheck/should_fail/tcfail004.stderr
testsuite/tests/typecheck/should_fail/tcfail033.stderr
testsuite/tests/typecheck/should_fail/tcfail049.stderr
testsuite/tests/typecheck/should_fail/tcfail050.stderr
testsuite/tests/typecheck/should_fail/tcfail140.stderr
testsuite/tests/typecheck/should_fail/tcfail198.stderr

index 8ece555..6021fdf 100644 (file)
@@ -34,9 +34,11 @@ module VarSet (
         intersectDVarSet, intersectsDVarSet, disjointDVarSet,
         isEmptyDVarSet, delDVarSet, delDVarSetList,
         minusDVarSet, foldDVarSet, filterDVarSet,
+        dVarSetMinusVarSet,
         transCloDVarSet,
         sizeDVarSet, seqDVarSet,
         partitionDVarSet,
+        dVarSetToVarSet,
     ) where
 
 #include "HsVersions.h"
@@ -47,7 +49,7 @@ import Name     ( Name )
 import UniqSet
 import UniqDSet
 import UniqFM( disjointUFM, pluralUFM, pprUFM )
-import UniqDFM( disjointUDFM )
+import UniqDFM( disjointUDFM, udfmToUfm )
 import Outputable (SDoc)
 
 -- | A non-deterministic set of variables.
@@ -248,6 +250,9 @@ delDVarSet = delOneFromUniqDSet
 minusDVarSet :: DVarSet -> DVarSet -> DVarSet
 minusDVarSet = minusUniqDSet
 
+dVarSetMinusVarSet :: DVarSet -> VarSet -> DVarSet
+dVarSetMinusVarSet = uniqDSetMinusUniqSet
+
 foldDVarSet :: (Var -> a -> a) -> a -> DVarSet -> a
 foldDVarSet = foldUniqDSet
 
@@ -272,6 +277,10 @@ seqDVarSet s = sizeDVarSet s `seq` ()
 extendDVarSetList :: DVarSet -> [Var] -> DVarSet
 extendDVarSetList = addListToUniqDSet
 
+-- | Convert a DVarSet to a VarSet by forgeting the order of insertion
+dVarSetToVarSet :: DVarSet -> VarSet
+dVarSetToVarSet = udfmToUfm
+
 -- | transCloVarSet for DVarSet
 transCloDVarSet :: (DVarSet -> DVarSet)
                   -- Map some variables in the set to
index 58f9ccc..c533399 100644 (file)
@@ -1441,7 +1441,7 @@ kindGeneralize :: TcType -> TcM [KindVar]
 -- type variables.  So in both cases, all the free vars are kind vars
 kindGeneralize kind_or_type
   = do { kvs <- zonkTcTypeAndFV kind_or_type
-       ; let dvs = DV { dv_kvs = kvs, dv_tvs = emptyVarSet }
+       ; let dvs = DV { dv_kvs = kvs, dv_tvs = emptyDVarSet }
        ; gbl_tvs <- tcGetGlobalTyCoVars -- Already zonked
        ; quantifyZonkedTyVars gbl_tvs dvs }
 
index 69de710..222a2e2 100644 (file)
@@ -831,6 +831,19 @@ has free vars {f,a}, but we must add 'k' as well! Hence step (3).
 * quantifyTyVars never quantifies over
     - a coercion variable
     - a runtime-rep variable
+
+Note [quantifyTyVars determinism]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+The results of quantifyTyVars are wrapped in a forall and can end up in the
+interface file. One such example is inferred type signatures. They also affect
+the results of optimizations, for example worker-wrapper. This means that to
+get deterministic builds quantifyTyVars needs to be deterministic.
+
+To achieve this TcDepVars is backed by deterministic sets which allows them
+to be later converted to a list in a deterministic order.
+
+For more information about deterministic sets see
+Note [Deterministic UniqFM] in UniqDFM.
 -}
 
 quantifyTyVars, quantifyZonkedTyVars
@@ -844,25 +857,25 @@ quantifyTyVars, quantifyZonkedTyVars
 -- The zonked variant assumes everything is already zonked.
 
 quantifyTyVars gbl_tvs (DV { dv_kvs = dep_tkvs, dv_tvs = nondep_tkvs })
-  = do { dep_tkvs    <- zonkTyCoVarsAndFV dep_tkvs
-       ; nondep_tkvs <- (`minusVarSet` dep_tkvs) <$>
-                        zonkTyCoVarsAndFV nondep_tkvs
+  = do { dep_tkvs    <- zonkTyCoVarsAndFVDSet dep_tkvs
+       ; nondep_tkvs <- (`minusDVarSet` dep_tkvs) <$>
+                        zonkTyCoVarsAndFVDSet nondep_tkvs
        ; gbl_tvs     <- zonkTyCoVarsAndFV gbl_tvs
        ; quantifyZonkedTyVars gbl_tvs (DV { dv_kvs = dep_tkvs, dv_tvs = nondep_tkvs }) }
 
 quantifyZonkedTyVars gbl_tvs (DV{ dv_kvs = dep_tkvs, dv_tvs = nondep_tkvs })
-  = do { let all_cvs = filterVarSet isCoVar dep_tkvs
-             dep_kvs = varSetElemsWellScoped $
-                       dep_tkvs `minusVarSet` gbl_tvs
-                                `minusVarSet` closeOverKinds all_cvs
-                 -- varSetElemsWellScoped: put the kind variables into
+  = do { let all_cvs = filterVarSet isCoVar $ dVarSetToVarSet dep_tkvs
+             dep_kvs = dVarSetElemsWellScoped $
+                       dep_tkvs `dVarSetMinusVarSet` gbl_tvs
+                                `dVarSetMinusVarSet` closeOverKinds all_cvs
+                 -- dVarSetElemsWellScoped: put the kind variables into
                  --    well-scoped order.
                  --    E.g.  [k, (a::k)] not the other way roud
                  -- closeOverKinds all_cvs: do not quantify over coercion
                  --    variables, or any any tvs that a covar depends on
 
-             nondep_tvs = varSetElems $
-                          nondep_tkvs `minusVarSet` gbl_tvs
+             nondep_tvs = dVarSetElems $
+                          nondep_tkvs `dVarSetMinusVarSet` gbl_tvs
                  -- No worry about dependent covars here; they are
                  --    all in dep_tkvs
                  -- No worry about scoping, becuase these are all
@@ -1170,7 +1183,7 @@ tcGetGlobalTyCoVars
 zonkTcTypeInKnot :: TcType -> TcM TcType
 zonkTcTypeInKnot = mapType (zonkTcTypeMapper { tcm_smart = False }) ()
 
-zonkTcTypeAndFV :: TcType -> TcM TyCoVarSet
+zonkTcTypeAndFV :: TcType -> TcM DTyCoVarSet
 -- Zonk a type and take its free variables
 -- With kind polymorphism it can be essential to zonk *first*
 -- so that we find the right set of free variables.  Eg
@@ -1180,7 +1193,7 @@ zonkTcTypeAndFV :: TcType -> TcM TyCoVarSet
 -- NB: This might be called from within the knot, so don't use
 -- smart constructors. See Note [Zonking within the knot] in TcHsType
 zonkTcTypeAndFV ty
-  = tyCoVarsOfType <$> zonkTcTypeInKnot ty
+  = tyCoVarsOfTypeDSet <$> zonkTcTypeInKnot ty
 
 -- | Zonk a type and call 'splitDepVarsOfType' on it.
 -- Works within the knot.
@@ -1206,6 +1219,13 @@ zonkTyCoVar tv | isTcTyVar tv = zonkTcTyVar tv
 zonkTyCoVarsAndFV :: TyCoVarSet -> TcM TyCoVarSet
 zonkTyCoVarsAndFV tycovars = tyCoVarsOfTypes <$> mapM zonkTyCoVar (varSetElems tycovars)
 
+-- Takes a deterministic set of TyCoVars, zonks them and returns a
+-- deterministic set of their free variables.
+-- See Note [quantifyTyVars determinism].
+zonkTyCoVarsAndFVDSet :: DTyCoVarSet -> TcM DTyCoVarSet
+zonkTyCoVarsAndFVDSet tycovars =
+  tyCoVarsOfTypesDSet <$> mapM zonkTyCoVar (dVarSetElems tycovars)
+
 zonkTcTyVars :: [TcTyVar] -> TcM [TcType]
 zonkTcTyVars tyvars = mapM zonkTcTyVar tyvars
 
index f7344af..4fce9de 100644 (file)
@@ -624,7 +624,9 @@ simplifyInfer rhs_tclvl apply_mr sigs name_taus wanteds
          -- so we must promote it!  The inferred type is just
          --   f :: beta -> beta
        ; zonked_tau_tkvs <- TcM.zonkTyCoVarsAndFV $
-                            dv_kvs zonked_tau_dvs `unionVarSet` dv_tvs zonked_tau_dvs
+                            dVarSetToVarSet (dv_kvs zonked_tau_dvs)
+                            `unionVarSet`
+                            dVarSetToVarSet (dv_tvs zonked_tau_dvs)
               -- decideQuantification turned some meta tyvars into
               -- quantified skolems, so we have to zonk again
 
@@ -747,7 +749,8 @@ decideQuantification apply_mr sigs name_taus constraints
                      zonked_dvs@(DV { dv_kvs = zonked_tau_kvs, dv_tvs = zonked_tau_tvs })
   | apply_mr     -- Apply the Monomorphism restriction
   = do { gbl_tvs <- tcGetGlobalTyCoVars
-       ; let zonked_tkvs = zonked_tau_kvs `unionVarSet` zonked_tau_tvs
+       ; let zonked_tkvs = dVarSetToVarSet zonked_tau_kvs `unionVarSet`
+                           dVarSetToVarSet zonked_tau_tvs
              constrained_tvs = tyCoVarsOfTypes constraints `unionVarSet`
                                filterVarSet isCoVar zonked_tkvs
              mono_tvs = gbl_tvs `unionVarSet` constrained_tvs
@@ -771,7 +774,7 @@ decideQuantification apply_mr sigs name_taus constraints
   | otherwise
   = do { gbl_tvs <- tcGetGlobalTyCoVars
        ; let mono_tvs     = growThetaTyVars equality_constraints gbl_tvs
-             tau_tvs_plus = growThetaTyVars constraints zonked_tau_tvs
+             tau_tvs_plus = growThetaTyVarsDSet constraints zonked_tau_tvs
              dvs_plus     = DV { dv_kvs = zonked_tau_kvs, dv_tvs = tau_tvs_plus }
        ; qtvs <- quantify_tvs sigs mono_tvs dvs_plus
           -- We don't grow the kvs, as there's no real need to. Recall
@@ -811,8 +814,8 @@ quantify_tvs sigs mono_tvs dep_tvs@(DV { dv_tvs = tau_tvs })
    -- NB: don't use quantifyZonkedTyVars because the sig stuff might
    -- be unzonked
   = quantifyTyVars (mono_tvs `delVarSetList` sig_qtvs)
-                   (dep_tvs { dv_tvs = tau_tvs `extendVarSetList` sig_qtvs
-                                               `extendVarSetList` sig_wcs })
+                   (dep_tvs { dv_tvs = tau_tvs `extendDVarSetList` sig_qtvs
+                                               `extendDVarSetList` sig_wcs })
                    -- NB: quantifyTyVars zonks its arguments
   where
     sig_qtvs = [ skol | sig <- sigs, (_, skol) <- sig_skols sig ]
@@ -842,6 +845,32 @@ growThetaTyVars theta tvs
        where
          pred_tvs = tyCoVarsOfType pred
 
+------------------
+growThetaTyVarsDSet :: ThetaType -> DTyCoVarSet -> DTyVarSet
+-- See Note [Growing the tau-tvs using constraints]
+-- NB: only returns tyvars, never covars
+-- It takes a deterministic set of TyCoVars and returns a deterministic set
+-- of TyVars.
+-- The implementation mirrors growThetaTyVars, the only difference is that
+-- it avoids unionDVarSet and uses more efficient extendDVarSetList.
+growThetaTyVarsDSet theta tvs
+  | null theta = tvs_only
+  | otherwise  = filterDVarSet isTyVar $
+                 transCloDVarSet mk_next seed_tvs
+  where
+    tvs_only = filterDVarSet isTyVar tvs
+    seed_tvs = tvs `extendDVarSetList` tyCoVarsOfTypesList ips
+    (ips, non_ips) = partition isIPPred theta
+                         -- See Note [Inheriting implicit parameters] in TcType
+
+    mk_next :: DVarSet -> DVarSet -- Maps current set to newly-grown ones
+    mk_next so_far = foldr (grow_one so_far) emptyDVarSet non_ips
+    grow_one so_far pred tvs
+       | any (`elemDVarSet` so_far) pred_tvs = tvs `extendDVarSetList` pred_tvs
+       | otherwise                           = tvs
+       where
+         pred_tvs = tyCoVarsOfTypeList pred
+
 {- Note [Which type variables to quantify]
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 When choosing type variables to quantify, the basic plan is to
index 83d491f..230c562 100644 (file)
@@ -851,13 +851,14 @@ allBoundVariabless = mapUnionVarSet allBoundVariables
 *                                                                      *
 ********************************************************************* -}
 
-data TcDepVars  -- See note [Dependent type variables]
-  = DV { dv_kvs :: TyCoVarSet  -- "kind" variables (dependent)
-       , dv_tvs :: TyVarSet    -- "type" variables (non-dependent)
-                               -- The two are disjoint sets
+data TcDepVars  -- See Note [Dependent type variables]
+                -- See Note [TcDepVars determinism]
+  = DV { dv_kvs :: DTyCoVarSet  -- "kind" variables (dependent)
+       , dv_tvs :: DTyVarSet    -- "type" variables (non-dependent)
+                                -- The two are disjoint sets
     }
 
-depVarsTyVars :: TcDepVars -> TyVarSet
+depVarsTyVars :: TcDepVars -> DTyVarSet
 depVarsTyVars = dv_tvs
 
 instance Outputable TcDepVars where
@@ -895,13 +896,26 @@ Note that
      (k1 :: k2), (k2 :: *)
   The "type variables" do not depend on each other; if
   one did, it'd be classified as a kind variable!
+
+Note [TcDepVars determinism]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+When we quantify over type variables we decide the order in which they
+appear in the final type. Because the order of type variables in the type
+can end up in the interface file and affects some optimizations like
+worker-wrapper we want this order to be deterministic.
+
+To achieve that we use deterministic sets of variables that can be converted to
+lists in a deterministic order.
+
+For more information about deterministic sets see
+Note [Deterministic UniqFM] in UniqDFM.
 -}
 
 splitDepVarsOfType :: Type -> TcDepVars
 -- See Note [Dependent type variables]
 splitDepVarsOfType ty
   = DV { dv_kvs = dep_vars
-       , dv_tvs = nondep_vars `minusVarSet` dep_vars }
+       , dv_tvs = nondep_vars `minusDVarSet` dep_vars }
   where
     Pair dep_vars nondep_vars = split_dep_vars ty
 
@@ -910,28 +924,30 @@ splitDepVarsOfTypes :: [Type] -> TcDepVars
 -- See Note [Dependent type variables]
 splitDepVarsOfTypes tys
   = DV { dv_kvs = dep_vars
-       , dv_tvs = nondep_vars `minusVarSet` dep_vars }
+       , dv_tvs = nondep_vars `minusDVarSet` dep_vars }
   where
     Pair dep_vars nondep_vars = foldMap split_dep_vars tys
 
 -- | Worker for 'splitDepVarsOfType'. This might output the same var
 -- in both sets, if it's used in both a type and a kind.
-split_dep_vars :: Type -> Pair TyCoVarSet   -- Pair kvs tvs
+-- See Note [TcDepVars determinism]
+split_dep_vars :: Type -> Pair DTyCoVarSet   -- Pair kvs tvs
 split_dep_vars = go
   where
-    go (TyVarTy tv)              = Pair (tyCoVarsOfType $ tyVarKind tv)
-                                        (unitVarSet tv)
+    go (TyVarTy tv)              = Pair (tyCoVarsOfTypeDSet $ tyVarKind tv)
+                                        (unitDVarSet tv)
     go (AppTy t1 t2)             = go t1 `mappend` go t2
     go (TyConApp _ tys)          = foldMap go tys
     go (ForAllTy (Anon arg) res) = go arg `mappend` go res
     go (ForAllTy (Named tv _) ty)
       = let Pair kvs tvs = go ty in
-        Pair (kvs `delVarSet` tv `unionVarSet` tyCoVarsOfType (tyVarKind tv))
-             (tvs `delVarSet` tv)
+        Pair (kvs `delDVarSet` tv
+                  `extendDVarSetList` tyCoVarsOfTypeList (tyVarKind tv))
+             (tvs `delDVarSet` tv)
     go (LitTy {})                = mempty
-    go (CastTy ty co)            = go ty `mappend` Pair (tyCoVarsOfCo co)
-                                                        emptyVarSet
-    go (CoercionTy co)           = Pair (tyCoVarsOfCo co) emptyVarSet
+    go (CastTy ty co)            = go ty `mappend` Pair (tyCoVarsOfCoDSet co)
+                                                        emptyDVarSet
+    go (CoercionTy co)           = Pair (tyCoVarsOfCoDSet co) emptyDVarSet
 
 {-
 ************************************************************************
index 42f9110..49c7267 100644 (file)
@@ -125,7 +125,7 @@ module Type (
         typeSize,
 
         -- * Well-scoped lists of variables
-        varSetElemsWellScoped, toposortTyVars, tyCoVarsOfTypeWellScoped,
+        dVarSetElemsWellScoped, toposortTyVars, tyCoVarsOfTypeWellScoped,
         tyCoVarsOfTypesWellScoped,
 
         -- * Type comparison
@@ -1867,9 +1867,14 @@ toposortTyVars tvs = reverse $
                          (tyCoVarsOfTypeList (tyVarKind tv)) )
             | tv <- tvs ]
 
--- | Extract a well-scoped list of variables from a set of variables.
-varSetElemsWellScoped :: VarSet -> [Var]
-varSetElemsWellScoped = toposortTyVars . varSetElems
+-- | Extract a well-scoped list of variables from a deterministic set of
+-- variables. The result is deterministic.
+-- NB: There used to exist varSetElemsWellScoped :: VarSet -> [Var] which
+-- took a non-deterministic set and produced a non-deterministic
+-- well-scoped list. If you care about the list being well-scoped you also
+-- most likely care about it being in deterministic order.
+dVarSetElemsWellScoped :: DVarSet -> [Var]
+dVarSetElemsWellScoped = toposortTyVars . dVarSetElems
 
 -- | Get the free vars of a type in scoped order
 tyCoVarsOfTypeWellScoped :: Type -> [TyVar]
index aecfc7f..7c16bc0 100644 (file)
@@ -1,7 +1,6 @@
 module Type where
 import TyCon
-import Var ( TyVar, TyCoVar )
-import VarSet ( TyCoVarSet )
+import Var ( TyVar )
 import {-# SOURCE #-} TyCoRep( Type, Kind )
 
 isPredTy :: Type -> Bool
@@ -20,4 +19,3 @@ partitionInvisibles :: TyCon -> (a -> Type) -> [a] -> ([a], [a])
 coreView :: Type -> Maybe Type
 
 tyCoVarsOfTypesWellScoped :: [Type] -> [TyVar]
-varSetElemsWellScoped :: TyCoVarSet -> [TyCoVar]
index c41e004..1b3cade 100644 (file)
@@ -44,6 +44,7 @@ module UniqDFM (
         intersectsUDFM,
         disjointUDFM,
         minusUDFM,
+        udfmMinusUFM,
         partitionUDFM,
 
         udfmToList,
@@ -59,7 +60,7 @@ import Data.Typeable
 import Data.Data
 import Data.List (sortBy)
 import Data.Function (on)
-import UniqFM (UniqFM, listToUFM_Directly, ufmToList)
+import UniqFM (UniqFM, listToUFM_Directly, ufmToList, ufmToIntMap)
 
 -- Note [Deterministic UniqFM]
 -- ~~~~~~~~~~~~~~~~~~~~~~~~~~~
@@ -239,6 +240,11 @@ minusUDFM (UDFM x i) (UDFM y _j) = UDFM (M.difference x y) i
   -- M.difference returns a subset of a left set, so `i` is a good upper
   -- bound.
 
+udfmMinusUFM :: UniqDFM elt1 -> UniqFM elt2 -> UniqDFM elt1
+udfmMinusUFM (UDFM x i) y = UDFM (M.difference x (ufmToIntMap y)) i
+  -- M.difference returns a subset of a left set, so `i` is a good upper
+  -- bound.
+
 -- | Partition UniqDFM into two UniqDFMs according to the predicate
 partitionUDFM :: (elt -> Bool) -> UniqDFM elt -> (UniqDFM elt, UniqDFM elt)
 partitionUDFM p (UDFM m i) =
@@ -283,6 +289,10 @@ alterUDFM f (UDFM m i) k =
 mapUDFM :: (elt1 -> elt2) -> UniqDFM elt1 -> UniqDFM elt2
 mapUDFM f (UDFM m i) = UDFM (M.map (fmap f) m) i
 
+instance Monoid (UniqDFM a) where
+  mempty = emptyUDFM
+  mappend = plusUDFM
+
 -- This should not be used in commited code, provided for convenience to
 -- make ad-hoc conversions when developing
 alwaysUnsafeUfmToUdfm :: UniqFM elt -> UniqDFM elt
index 45ed241..90e9996 100644 (file)
@@ -19,7 +19,7 @@ module UniqDSet (
         mkUniqDSet,
         addOneToUniqDSet, addListToUniqDSet,
         unionUniqDSets, unionManyUniqDSets,
-        minusUniqDSet,
+        minusUniqDSet, uniqDSetMinusUniqSet,
         intersectUniqDSets,
         intersectsUniqDSets,
         foldUniqDSet,
@@ -33,6 +33,7 @@ module UniqDSet (
     ) where
 
 import UniqDFM
+import UniqSet
 import Unique
 
 type UniqDSet a = UniqDFM a
@@ -65,9 +66,12 @@ unionManyUniqDSets :: [UniqDSet a] -> UniqDSet a
 unionManyUniqDSets [] = emptyUniqDSet
 unionManyUniqDSets sets = foldr1 unionUniqDSets sets
 
-minusUniqDSet  :: UniqDSet a -> UniqDSet a -> UniqDSet a
+minusUniqDSet :: UniqDSet a -> UniqDSet a -> UniqDSet a
 minusUniqDSet = minusUDFM
 
+uniqDSetMinusUniqSet :: UniqDSet a -> UniqSet a -> UniqDSet a
+uniqDSetMinusUniqSet = udfmMinusUFM
+
 intersectUniqDSets :: UniqDSet a -> UniqDSet a -> UniqDSet a
 intersectUniqDSets = intersectUDFM
 
index 3632926..10cc179 100644 (file)
@@ -66,7 +66,7 @@ module UniqFM (
         lookupWithDefaultUFM, lookupWithDefaultUFM_Directly,
         eltsUFM, keysUFM, splitUFM,
         ufmToSet_Directly,
-        ufmToList,
+        ufmToList, ufmToIntMap,
         joinUFM, pprUniqFM, pprUFM, pluralUFM
     ) where
 
@@ -298,6 +298,9 @@ eltsUFM (UFM m) = M.elems m
 ufmToSet_Directly (UFM m) = M.keysSet m
 ufmToList (UFM m) = map (\(k, v) -> (getUnique k, v)) $ M.toList m
 
+ufmToIntMap :: UniqFM elt -> M.IntMap elt
+ufmToIntMap (UFM m) = m
+
 -- Hoopl
 joinUFM :: JoinFun v -> JoinFun (UniqFM v)
 joinUFM eltJoin l (OldFact old) (NewFact new) = foldUFM_Directly add (NoChange, old) new
index c6c5e35..6a39e6d 100644 (file)
@@ -2,29 +2,29 @@ TYPE SIGNATURES
   test1 ::
     forall (f :: * -> *). Applicative f => (Int -> f Int) -> f Int
   test2 ::
-    forall (f :: * -> *) b t.
+    forall t b (f :: * -> *).
     (Applicative f, Num t, Num b) =>
     (t -> f b) -> f b
   test2a ::
-    forall (f :: * -> *) b t.
+    forall t b (f :: * -> *).
     (Num t, Num b, Functor f) =>
     (t -> f b) -> f b
   test2b ::
     forall (m :: * -> *) a t. (Num t, Monad m) => (t -> a) -> m a
   test3 ::
-    forall (m :: * -> *) a t t1.
-    (Num t, Monad m) =>
-    (t -> m t1) -> (t1 -> t1 -> m a) -> m a
+    forall a t (m :: * -> *) t1.
+    (Num t1, Monad m) =>
+    (t1 -> m t) -> (t -> t -> m a) -> m a
   test4 ::
-    forall (m :: * -> *) a a1 t.
+    forall a a1 (m :: * -> *) t.
     (Num t, Monad m) =>
     (t -> m a1) -> (a1 -> a1 -> m a) -> m a
   test5 ::
-    forall (m :: * -> *) a a1 t.
+    forall a a1 (m :: * -> *) t.
     (Num t, Monad m) =>
     (t -> m a1) -> (a1 -> a1 -> m a) -> m a
   test6 ::
-    forall t (m :: * -> *) a.
+    forall a (m :: * -> *) t.
     (Num (m a), Monad m) =>
     (m a -> m (m a)) -> t -> m a
 TYPE CONSTRUCTORS
index 8f4251b..4fcc593 100644 (file)
@@ -1,7 +1,7 @@
 
 T11334b.hs:8:14: error:
     • Cannot default kind variable ‘f0’
-      of kind: k0 -> *
+      of kind: k10 -> *
       Perhaps enable PolyKinds or add a kind signature
     • In an expression type signature: Proxy Compose
       In the expression: Proxy :: Proxy Compose
@@ -9,7 +9,7 @@ T11334b.hs:8:14: error:
 
 T11334b.hs:8:14: error:
     • Cannot default kind variable ‘g0’
-      of kind: k10 -> k0
+      of kind: k0 -> k10
       Perhaps enable PolyKinds or add a kind signature
     • In an expression type signature: Proxy Compose
       In the expression: Proxy :: Proxy Compose
@@ -17,7 +17,7 @@ T11334b.hs:8:14: error:
 
 T11334b.hs:8:14: error:
     • Cannot default kind variable ‘a0’
-      of kind: k10
+      of kind: k0
       Perhaps enable PolyKinds or add a kind signature
     • In an expression type signature: Proxy Compose
       In the expression: Proxy :: Proxy Compose
index 398d885..8f2e603 100644 (file)
@@ -18,7 +18,7 @@ werror.hs:10:1: warning: [-Wunused-top-binds (in -Wextra, -Wunused-binds)]
 
 werror.hs:10:1: warning: [-Wmissing-signatures (in -Wall)]
     Top-level binding with no type signature:
-      f :: forall t t1. [t] -> [t1]
+      f :: forall t t1. [t1] -> [t]
 
 werror.hs:10:1: warning: [-Wincomplete-patterns (in -Wextra)]
     Pattern match(es) are non-exhaustive
index bc14bf1..797fd0b 100644 (file)
@@ -1,17 +1,17 @@
 
 gadt13.hs:15:13: error:
-    • Couldn't match expected type ‘t1
+    • Couldn't match expected type ‘t’
                   with actual type ‘String -> [Char]’
-        ‘t1’ is untouchable
-          inside the constraints: t ~ Int
+        ‘t’ is untouchable
+          inside the constraints: t1 ~ Int
           bound by a pattern with constructor: I :: Int -> Term Int,
                    in an equation for ‘shw’
           at gadt13.hs:15:6-8
-      ‘t1’ is a rigid type variable bound by
-        the inferred type of shw :: Term t -> t1 at gadt13.hs:15:1
+      ‘t’ is a rigid type variable bound by
+        the inferred type of shw :: Term t1 -> t at gadt13.hs:15:1
       Possible fix: add a type signature for ‘shw’
     • Possible cause: ‘(.)’ is applied to too many arguments
       In the expression: ("I " ++) . shows t
       In an equation for ‘shw’: shw (I t) = ("I " ++) . shows t
     • Relevant bindings include
-        shw :: Term t -> t1 (bound at gadt13.hs:15:1)
+        shw :: Term t1 -> t (bound at gadt13.hs:15:1)
index 8219bee..35c8e10 100644 (file)
@@ -1,20 +1,20 @@
 
 gadt7.hs:16:38: error:
-    • Couldn't match expected type ‘t2’ with actual type ‘t
-        ‘t2’ is untouchable
-          inside the constraints: t1 ~ Int
+    • Couldn't match expected type ‘t’ with actual type ‘t1
+        ‘t’ is untouchable
+          inside the constraints: t2 ~ Int
           bound by a pattern with constructor: K :: T Int,
                    in a case alternative
           at gadt7.hs:16:33
-      ‘t2’ is a rigid type variable bound by
-        the inferred type of i1b :: T t1 -> t -> t2 at gadt7.hs:16:1
       ‘t’ is a rigid type variable bound by
-        the inferred type of i1b :: T t1 -> t -> t2 at gadt7.hs:16:1
+        the inferred type of i1b :: T t2 -> t1 -> t at gadt7.hs:16:1
+      ‘t1’ is a rigid type variable bound by
+        the inferred type of i1b :: T t2 -> t1 -> t at gadt7.hs:16:1
       Possible fix: add a type signature for ‘i1b’
     • In the expression: y1
       In a case alternative: K -> y1
       In the expression: case t1 of { K -> y1 }
     • Relevant bindings include
-        y1 :: t (bound at gadt7.hs:16:16)
-        y :: t (bound at gadt7.hs:16:7)
-        i1b :: T t1 -> t -> t2 (bound at gadt7.hs:16:1)
+        y1 :: t1 (bound at gadt7.hs:16:16)
+        y :: t1 (bound at gadt7.hs:16:7)
+        i1b :: T t2 -> t1 -> t (bound at gadt7.hs:16:1)
index 90c1f2e..260ef49 100644 (file)
@@ -1,8 +1,8 @@
 Stopped in Test.foldl, break026.hs:5:16-22
 _result :: Integer = _
 c :: Integer = 0
-go :: Integer -> [t1] -> Integer = _
-xs :: [t1] = _
+go :: Integer -> [t] -> Integer = _
+xs :: [t] = _
 Stopped in Test.foldl.go, break026.hs:7:23-35
 _result :: Integer = _
 c :: Integer = 0
@@ -10,17 +10,17 @@ f :: Integer -> Integer -> Integer = _
 x :: Integer = 1
 xs :: [Integer] = _
 Stopped in Test.foldl.go, break026.hs:7:23-35
-_result :: t = _
-c :: t = _
-f :: t -> Integer -> t = _
+_result :: t1 = _
+c :: t1 = _
+f :: t1 -> Integer -> t1 = _
 x :: Integer = 2
 xs :: [Integer] = _
 c = 1
 Stopped in Test.foldl, break026.hs:5:16-22
 _result :: Integer = _
 c :: Integer = 0
-go :: Integer -> [t1] -> Integer = _
-xs :: [t1] = _
+go :: Integer -> [t] -> Integer = _
+xs :: [t] = _
 Stopped in Test.foldl.go, break026.hs:7:23-35
 _result :: Integer = _
 c :: Integer = 0
@@ -28,9 +28,9 @@ f :: Integer -> Integer -> Integer = _
 x :: Integer = 1
 xs :: [Integer] = _
 Stopped in Test.foldl.go, break026.hs:7:23-35
-_result :: t = _
-c :: t = _
-f :: t -> Integer -> t = _
+_result :: t1 = _
+c :: t1 = _
+f :: t1 -> Integer -> t1 = _
 x :: Integer = 2
 xs :: [Integer] = _
 Stopped in Test.foldl.go, break026.hs:7:27-31
index 91d51d3..0a9dddb 100644 (file)
@@ -31,7 +31,7 @@ pattern Pue :: forall {t}. () => forall {a}. t -> a -> (t, Ex)
        -- Defined at <interactive>:19:1
 pattern Pur :: forall {a}. (Num a, Eq a) => a -> [a]
        -- Defined at <interactive>:20:1
-pattern Purp :: forall {a} {t}. (Num a, Eq a) => Show t => a
+pattern Purp :: forall {t} {a}. (Num a, Eq a) => Show t => a
                                                            -> t -> ([a], UnivProv t)
        -- Defined at <interactive>:21:1
 pattern Pure :: forall {a}. (Num a, Eq a) => forall {a1}. a
index 5964262..f06760e 100644 (file)
@@ -42,7 +42,7 @@
         (i.e. ones independent of the class type variables)
         must be distinct type variables
       Expected: PolyKindVarsF '[]
-      Actual:   PolyKindVarsF '[]
+        Actual: PolyKindVarsF '[]
       Use -fprint-explicit-kinds to see the kind arguments
     • In the type instance declaration for ‘PolyKindVarsF’
       In the instance declaration for ‘PolyKindVarsC '[]’
@@ -59,7 +59,7 @@
     Kind variable ‘k’ cannot be inferred from the right-hand side.
     Use -fprint-explicit-kinds to see the kind arguments
     In the type family equation:
-      forall k (a :: k) (b :: k).
+      forall k (b :: k) (a :: k).
         Fc a b = Int -- Defined at <interactive>:64:15
 
 <interactive>:68:15: error:
@@ -68,7 +68,7 @@
     cannot be inferred from the right-hand side.
     Use -fprint-explicit-kinds to see the kind arguments
     In the type family equation:
-      forall k (a :: k) (b :: k).
+      forall k (b :: k) (a :: k).
         Gc a b = Int -- Defined at <interactive>:68:15
 
 <interactive>:81:15: error:
index fcf9e4c..94837b4 100644 (file)
@@ -1,7 +1,7 @@
 type role A phantom phantom
-data A (x :: k) (y :: k1)
+data A (x :: k1) (y :: k)
        -- Defined at <interactive>:2:1
-A :: k -> k1 -> *
+A :: k1 -> k -> *
 type role T phantom
 data T (a :: k) where
   MkT :: forall k (a :: k) a1. a1 -> T a
index 2b2c8b7..0b41ebb 100644 (file)
@@ -16,12 +16,12 @@ H :: Bool -> Bool
 type family J (a :: [k]) :: Bool
   where
     [k] J k '[] = 'False
-    [k, (h :: k), (t :: [k])] J k (h : t) = 'True
+    [k, (t :: [k]), (h :: k)] J k (h : t) = 'True
        -- Defined at T7939.hs:17:1
 J :: [k] -> Bool
 type family K (a1 :: [a]) :: Maybe a
   where
     [a] K a '[] = 'Nothing
-    [a, (h :: a), (t :: [a])] K a (h : t) = 'Just h
+    [a, (t :: [a]), (h :: a)] K a (h : t) = 'Just h
        -- Defined at T7939.hs:21:1
 K :: [a] -> Maybe a
index 937a270..d0d9bd5 100644 (file)
@@ -1,2 +1,2 @@
-pattern P :: () => (Num t, Eq t1) => A t t1
+pattern P :: () => (Num t1, Eq t) => A t1 t
        -- Defined at T8776.hs:6:1
index 3000395..bedb722 100644 (file)
@@ -4,7 +4,7 @@ TYPE SIGNATURES
   emptyL :: forall a. ListColl a
   insert :: forall c. Coll c => Elem c -> c -> c
   test2 ::
-    forall c t t1. (Elem c ~ (t, t1), Coll c, Num t1, Num t) => c -> c
+    forall t t1 c. (Elem c ~ (t, t1), Coll c, Num t1, Num t) => c -> c
 TYPE CONSTRUCTORS
   class Coll c where
     type family Elem c :: * open
index b93be8c..81359b2 100644 (file)
@@ -1,6 +1,6 @@
 
 T8889.hs:12:1: warning: [-Wmissing-signatures (in -Wall)]
     Top-level binding with no type signature:
-      f :: forall (f :: * -> *) a b.
+      f :: forall (f :: * -> *) b a.
            (C f, C_fmap f a) =>
            (a -> b) -> f a -> f b
index b56db13..0332181 100644 (file)
@@ -1,11 +1,11 @@
 
 T7354.hs:28:11: error:
     • Occurs check: cannot construct the infinite type:
-        t1 ~ Base t (Prim [t1] t1)
-      Expected type: Prim [t1] t1 -> Base t (Prim [t1] t1)
-        Actual type: Prim [t1] t1 -> t1
+        t ~ Base t1 (Prim [t] t)
+      Expected type: Prim [t] t -> Base t1 (Prim [t] t)
+        Actual type: Prim [t] t -> t
     • In the first argument of ‘ana’, namely ‘alg’
       In the expression: ana alg
       In an equation for ‘foo’: foo = ana alg
     • Relevant bindings include
-        foo :: Prim [t1] t1 -> t (bound at T7354.hs:28:1)
+        foo :: Prim [t] t -> t1 (bound at T7354.hs:28:1)
index 037bb76..a152f55 100644 (file)
@@ -18,9 +18,9 @@ T8518.hs:14:18: error:
         callCont :: c -> Z c -> B c -> Maybe (F c) (bound at T8518.hs:14:1)
 
 T8518.hs:16:9: error:
-    • Couldn't match type ‘F t1’ with ‘Z t1 -> B t1 -> F t1
-      Expected type: t -> t1 -> F t1
-        Actual type: t -> t1 -> Z t1 -> B t1 -> F t1
+    • Couldn't match type ‘F t’ with ‘Z t -> B t -> F t
+      Expected type: t1 -> t -> F t
+        Actual type: t1 -> t -> Z t -> B t -> F t
     • In an equation for ‘callCont’:
           callCont c z b
             = rpt (4 :: Int) c z b
@@ -28,4 +28,4 @@ T8518.hs:16:9: error:
                 rpt 0 c' z' b' = fromJust (fst <$> (continue c' z' b'))
                 rpt i c' z' b' = let ... in rpt (i - 1) c''
     • Relevant bindings include
-        rpt :: t -> t1 -> F t1 (bound at T8518.hs:16:9)
+        rpt :: t1 -> t -> F t (bound at T8518.hs:16:9)
index 9480e92..d02aac2 100644 (file)
@@ -1,12 +1,12 @@
 
 mod71.hs:4:9: error:
-    • Found hole: _ :: t
-      Where: ‘t’ is a rigid type variable bound by
-               the inferred type of f :: Num t1 => (t -> t1 -> t2) -> t2
+    • Found hole: _ :: t1
+      Where: ‘t1’ is a rigid type variable bound by
+               the inferred type of f :: Num t => (t1 -> t -> t2) -> t2
                at mod71.hs:4:1
     • In the first argument of ‘x’, namely ‘_’
       In the expression: x _ 1
       In an equation for ‘f’: f x = x _ 1
     • Relevant bindings include
-        x :: t -> t1 -> t2 (bound at mod71.hs:4:3)
-        f :: (t -> t1 -> t2) -> t2 (bound at mod71.hs:4:1)
+        x :: t1 -> t -> t2 (bound at mod71.hs:4:3)
+        f :: (t1 -> t -> t2) -> t2 (bound at mod71.hs:4:1)
index 69246ed..f546dc8 100644 (file)
@@ -1,2 +1,2 @@
 
-mod72.hs:3:7: error: Variable not in scope: g :: t -> t1
+mod72.hs:3:7: error: Variable not in scope: g :: t1 -> t
index 4b324b1..d7c43e5 100644 (file)
@@ -1,7 +1,7 @@
 
 read014.hs:4:1: warning: [-Wmissing-signatures (in -Wall)]
     Top-level binding with no type signature:
-      ng1 :: forall t a. Num a => t -> a -> a
+      ng1 :: forall a t. Num a => t -> a -> a
 
 read014.hs:4:5: warning: [-Wunused-matches (in -Wextra)]
     Defined but not used: ‘x’
index e837eee..963bc50 100644 (file)
@@ -1,7 +1,7 @@
 
 readFail003.hs:4:27: error:
     • Occurs check: cannot construct the infinite type:
-        t ~ (t, [a], [a1])
+        t ~ (t, [a1], [a])
     • In the expression: a
       In a pattern binding:
         ~(a, b, c)
@@ -12,5 +12,5 @@ readFail003.hs:4:27: error:
               nullity = null
     • Relevant bindings include
         a :: t (bound at readFail003.hs:4:3)
-        b :: [a] (bound at readFail003.hs:4:5)
-        c :: [a1] (bound at readFail003.hs:4:7)
+        b :: [a1] (bound at readFail003.hs:4:5)
+        c :: [a] (bound at readFail003.hs:4:7)
index c34b139..ee31ed2 100644 (file)
@@ -1,28 +1,28 @@
 TYPE SIGNATURES
   !! :: forall a. [a] -> Int -> a
-  $ :: forall a b. (a -> b) -> a -> b
-  $! :: forall a b. (a -> b) -> a -> b
+  $ :: forall b a. (a -> b) -> a -> b
+  $! :: forall b a. (a -> b) -> a -> b
   && :: Bool -> Bool -> Bool
   * :: forall a. Num a => a -> a -> a
   ** :: forall a. Floating a => a -> a -> a
   + :: forall a. Num a => a -> a -> a
   ++ :: forall a. [a] -> [a] -> [a]
   - :: forall a. Num a => a -> a -> a
-  . :: forall b c a. (b -> c) -> (a -> b) -> a -> c
+  . :: forall a c b. (b -> c) -> (a -> b) -> a -> c
   / :: forall a. Fractional a => a -> a -> a
   /= :: forall a. Eq a => a -> a -> Bool
   < :: forall a. Ord a => a -> a -> Bool
   <= :: forall a. Ord a => a -> a -> Bool
   =<< ::
-    forall (m :: * -> *) a b. Monad m => (a -> m b) -> m a -> m b
+    forall (m :: * -> *) b a. Monad m => (a -> m b) -> m a -> m b
   == :: forall a. Eq a => a -> a -> Bool
   > :: forall a. Ord a => a -> a -> Bool
   >= :: forall a. Ord a => a -> a -> Bool
-  >> :: forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
+  >> :: forall b (m :: * -> *) a. Monad m => m a -> m b -> m b
   >>= ::
-    forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b
-  ^ :: forall a b. (Num a, Integral b) => a -> b -> a
-  ^^ :: forall a b. (Integral b, Fractional a) => a -> b -> a
+    forall b (m :: * -> *) a. Monad m => m a -> (a -> m b) -> m b
+  ^ :: forall b a. (Num a, Integral b) => a -> b -> a
+  ^^ :: forall b a. (Integral b, Fractional a) => a -> b -> a
   abs :: forall a. Num a => a -> a
   acos :: forall a. Floating a => a -> a
   acosh :: forall a. Floating a => a -> a
@@ -39,22 +39,22 @@ TYPE SIGNATURES
   atan2 :: forall a. RealFloat a => a -> a -> a
   atanh :: forall a. Floating a => a -> a
   break :: forall a. (a -> Bool) -> [a] -> ([a], [a])
-  ceiling :: forall a b. (RealFrac a, Integral b) => a -> b
+  ceiling :: forall b a. (RealFrac a, Integral b) => a -> b
   compare :: forall a. Ord a => a -> a -> Ordering
   concat :: forall (t :: * -> *) a. P.Foldable t => t [a] -> [a]
   concatMap ::
-    forall (t :: * -> *) a b. P.Foldable t => (a -> [b]) -> t a -> [b]
-  const :: forall a b. a -> b -> a
+    forall (t :: * -> *) b a. P.Foldable t => (a -> [b]) -> t a -> [b]
+  const :: forall b a. a -> b -> a
   cos :: forall a. Floating a => a -> a
   cosh :: forall a. Floating a => a -> a
-  curry :: forall a b c. ((a, b) -> c) -> a -> b -> c
+  curry :: forall c a b. ((a, b) -> c) -> a -> b -> c
   cycle :: forall a. [a] -> [a]
   decodeFloat :: forall a. RealFloat a => a -> (Integer, Int)
   div :: forall a. Integral a => a -> a -> a
   divMod :: forall a. Integral a => a -> a -> (a, a)
   drop :: forall a. Int -> [a] -> [a]
   dropWhile :: forall a. (a -> Bool) -> [a] -> [a]
-  either :: forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
+  either :: forall b c a. (a -> c) -> (b -> c) -> Either a b -> c
   elem ::
     forall (t :: * -> *) a. (P.Foldable t, Eq a) => a -> t a -> Bool
   encodeFloat :: forall a. RealFloat a => Integer -> Int -> a
@@ -68,28 +68,28 @@ TYPE SIGNATURES
   exponent :: forall a. RealFloat a => a -> Int
   fail :: forall (m :: * -> *) a. Monad m => String -> m a
   filter :: forall a. (a -> Bool) -> [a] -> [a]
-  flip :: forall a b c. (a -> b -> c) -> b -> a -> c
+  flip :: forall c b a. (a -> b -> c) -> b -> a -> c
   floatDigits :: forall a. RealFloat a => a -> Int
   floatRadix :: forall a. RealFloat a => a -> Integer
   floatRange :: forall a. RealFloat a => a -> (Int, Int)
-  floor :: forall a b. (RealFrac a, Integral b) => a -> b
+  floor :: forall b a. (RealFrac a, Integral b) => a -> b
   fmap ::
-    forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
+    forall (f :: * -> *) b a. Functor f => (a -> b) -> f a -> f b
   foldl ::
-    forall (t :: * -> *) b a.
+    forall (t :: * -> *) a b.
     P.Foldable t =>
     (b -> a -> b) -> b -> t a -> b
   foldl1 ::
     forall (t :: * -> *) a. P.Foldable t => (a -> a -> a) -> t a -> a
   foldr ::
-    forall (t :: * -> *) a b.
+    forall (t :: * -> *) b a.
     P.Foldable t =>
     (a -> b -> b) -> b -> t a -> b
   foldr1 ::
     forall (t :: * -> *) a. P.Foldable t => (a -> a -> a) -> t a -> a
   fromEnum :: forall a. Enum a => a -> Int
   fromInteger :: forall a. Num a => Integer -> a
-  fromIntegral :: forall a b. (Num b, Integral a) => a -> b
+  fromIntegral :: forall b a. (Num b, Integral a) => a -> b
   fromRational :: forall a. Fractional a => Rational -> a
   fst :: forall a b. (a, b) -> a
   gcd :: forall a. Integral a => a -> a -> a
@@ -114,21 +114,21 @@ TYPE SIGNATURES
   lines :: String -> [String]
   log :: forall a. Floating a => a -> a
   logBase :: forall a. Floating a => a -> a -> a
-  lookup :: forall a b. Eq a => a -> [(a, b)] -> Maybe b
-  map :: forall a b. (a -> b) -> [a] -> [b]
+  lookup :: forall b a. Eq a => a -> [(a, b)] -> Maybe b
+  map :: forall b a. (a -> b) -> [a] -> [b]
   mapM ::
-    forall (t :: * -> *) (m :: * -> *) a b.
+    forall (t :: * -> *) (m :: * -> *) b a.
     (P.Traversable t, Monad m) =>
     (a -> m b) -> t a -> m (t b)
   mapM_ ::
-    forall (t :: * -> *) (m :: * -> *) a b.
+    forall (t :: * -> *) (m :: * -> *) b a.
     (P.Foldable t, Monad m) =>
     (a -> m b) -> t a -> m ()
   max :: forall a. Ord a => a -> a -> a
   maxBound :: forall t. Bounded t => t
   maximum ::
     forall (t :: * -> *) a. (P.Foldable t, Ord a) => t a -> a
-  maybe :: forall b a. b -> (a -> b) -> Maybe a -> b
+  maybe :: forall a b. b -> (a -> b) -> Maybe a -> b
   min :: forall a. Ord a => a -> a -> a
   minBound :: forall t. Bounded t => t
   minimum ::
@@ -148,7 +148,7 @@ TYPE SIGNATURES
   product ::
     forall (t :: * -> *) a. (P.Foldable t, Num a) => t a -> a
   properFraction ::
-    forall a b. (RealFrac a, Integral b) => a -> (b, a)
+    forall b a. (RealFrac a, Integral b) => a -> (b, a)
   putChar :: Char -> IO ()
   putStr :: String -> IO ()
   putStrLn :: String -> IO ()
@@ -162,20 +162,20 @@ TYPE SIGNATURES
   readParen :: forall a. Bool -> ReadS a -> ReadS a
   reads :: forall a. Read a => ReadS a
   readsPrec :: forall a. Read a => Int -> ReadS a
-  realToFrac :: forall a b. (Real a, Fractional b) => a -> b
+  realToFrac :: forall b a. (Real a, Fractional b) => a -> b
   recip :: forall a. Fractional a => a -> a
   rem :: forall a. Integral a => a -> a -> a
   repeat :: forall a. a -> [a]
   replicate :: forall a. Int -> a -> [a]
   return :: forall (m :: * -> *) a. Monad m => a -> m a
   reverse :: forall a. [a] -> [a]
-  round :: forall a b. (RealFrac a, Integral b) => a -> b
+  round :: forall b a. (RealFrac a, Integral b) => a -> b
   scaleFloat :: forall a. RealFloat a => Int -> a -> a
-  scanl :: forall b a. (b -> a -> b) -> b -> [a] -> [b]
+  scanl :: forall a b. (b -> a -> b) -> b -> [a] -> [b]
   scanl1 :: forall a. (a -> a -> a) -> [a] -> [a]
-  scanr :: forall a b. (a -> b -> b) -> b -> [a] -> [b]
+  scanr :: forall b a. (a -> b -> b) -> b -> [a] -> [b]
   scanr1 :: forall a. (a -> a -> a) -> [a] -> [a]
-  seq :: forall a b. a -> b -> b
+  seq :: forall b a. a -> b -> b
   sequence ::
     forall (t :: * -> *) (m :: * -> *) a.
     (P.Traversable t, Monad m) =>
@@ -210,8 +210,8 @@ TYPE SIGNATURES
   toEnum :: forall a. Enum a => Int -> a
   toInteger :: forall a. Integral a => a -> Integer
   toRational :: forall a. Real a => a -> Rational
-  truncate :: forall a b. (RealFrac a, Integral b) => a -> b
-  uncurry :: forall a b c. (a -> b -> c) -> (a, b) -> c
+  truncate :: forall b a. (RealFrac a, Integral b) => a -> b
+  uncurry :: forall c b a. (a -> b -> c) -> (a, b) -> c
   undefined :: forall t. t
   unlines :: [String] -> String
   until :: forall a. (a -> Bool) -> (a -> a) -> a -> a
@@ -221,11 +221,11 @@ TYPE SIGNATURES
   userError :: String -> IOError
   words :: String -> [String]
   writeFile :: FilePath -> String -> IO ()
-  zip :: forall a b. [a] -> [b] -> [(a, b)]
-  zip3 :: forall a b c. [a] -> [b] -> [c] -> [(a, b, c)]
-  zipWith :: forall a b c. (a -> b -> c) -> [a] -> [b] -> [c]
+  zip :: forall b a. [a] -> [b] -> [(a, b)]
+  zip3 :: forall c b a. [a] -> [b] -> [c] -> [(a, b, c)]
+  zipWith :: forall c b a. (a -> b -> c) -> [a] -> [b] -> [c]
   zipWith3 ::
-    forall a b c d. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
+    forall d c b a. (a -> b -> c -> d) -> [a] -> [b] -> [c] -> [d]
   || :: Bool -> Bool -> Bool
 TYPE CONSTRUCTORS
 COERCION AXIOMS
index 88cf133..3e07437 100644 (file)
@@ -1,7 +1,7 @@
 TYPE SIGNATURES
-  foo :: forall b a. (a, b) -> (a, b)
+  foo :: forall a b. (a, b) -> (a, b)
 TYPE CONSTRUCTORS
 COERCION AXIOMS
 Dependent modules: []
 Dependent packages: [base-4.9.0.0, ghc-prim-0.5.0.0,
-                     integer-gmp-1.0.0.0]
+                     integer-gmp-1.0.0.1]
index 5b94077..6209498 100644 (file)
@@ -2,7 +2,7 @@ TYPE SIGNATURES
   SkipMany.GenParser ::
     forall tok st a. tok -> st -> a -> GenParser tok st a
   skipMany ::
-    forall tok st a. GenParser tok st a -> GenParser tok st ()
+    forall a tok st. GenParser tok st a -> GenParser tok st ()
   skipMany' ::
     forall tok st a. GenParser tok st a -> GenParser tok st ()
 TYPE CONSTRUCTORS
index 3871a63..0742250 100644 (file)
@@ -24,5 +24,5 @@ T10438.hs:7:22: warning: [-Wpartial-type-signatures (in -Wdefault)]
         x :: t2 (bound at T10438.hs:8:17)
         r :: t2 (bound at T10438.hs:6:11)
         g :: t2 -> t2 (bound at T10438.hs:6:9)
-        f :: t (bound at T10438.hs:5:5)
-        foo :: t -> forall t1. t1 -> t1 (bound at T10438.hs:5:1)
+        f :: t1 (bound at T10438.hs:5:5)
+        foo :: t1 -> forall t. t -> t (bound at T10438.hs:5:1)
index 58116f8..2ff8d3d 100644 (file)
@@ -1,5 +1,5 @@
 TYPE SIGNATURES
-  unc :: forall t a b. (a -> b -> t) -> (a, b) -> t
+  unc :: forall a b t. (a -> b -> t) -> (a, b) -> t
 TYPE CONSTRUCTORS
 COERCION AXIOMS
 Dependent modules: []
index 7013696..b5268ac 100644 (file)
@@ -1,5 +1,5 @@
 TYPE SIGNATURES
-  bar :: forall t t1. t1 -> (t1 -> t) -> t
+  bar :: forall t t1. t -> (t -> t1) -> t1
   foo :: forall a. (Show a, Enum a) => a -> String
 TYPE CONSTRUCTORS
 COERCION AXIOMS
@@ -30,37 +30,37 @@ WarningWildcardInstantiations.hs:5:30: warning: [-Wpartial-type-signatures (in -
         foo :: a -> String (bound at WarningWildcardInstantiations.hs:6:1)
 
 WarningWildcardInstantiations.hs:8:8: warning: [-Wpartial-type-signatures (in -Wdefault)]
-    • Found type wildcard ‘_’ standing for ‘t1
-      Where: ‘t1’ is a rigid type variable bound by
-               the inferred type of bar :: t1 -> (t1 -> t) -> t
+    • Found type wildcard ‘_’ standing for ‘t’
+      Where: ‘t’ is a rigid type variable bound by
+               the inferred type of bar :: t -> (t -> t1) -> t1
                at WarningWildcardInstantiations.hs:9:1
     • In the type signature:
         bar :: _ -> _ -> _
     • Relevant bindings include
-        bar :: t1 -> (t1 -> t) -> t
+        bar :: t -> (t -> t1) -> t1
           (bound at WarningWildcardInstantiations.hs:9:1)
 
 WarningWildcardInstantiations.hs:8:13: warning: [-Wpartial-type-signatures (in -Wdefault)]
-    • Found type wildcard ‘_’ standing for ‘t1 -> t
-      Where: ‘t’ is a rigid type variable bound by
-               the inferred type of bar :: t1 -> (t1 -> t) -> t
+    • Found type wildcard ‘_’ standing for ‘t -> t1
+      Where: ‘t1’ is a rigid type variable bound by
+               the inferred type of bar :: t -> (t -> t1) -> t1
                at WarningWildcardInstantiations.hs:9:1
-             ‘t1’ is a rigid type variable bound by
-               the inferred type of bar :: t1 -> (t1 -> t) -> t
+             ‘t’ is a rigid type variable bound by
+               the inferred type of bar :: t -> (t -> t1) -> t1
                at WarningWildcardInstantiations.hs:9:1
     • In the type signature:
         bar :: _ -> _ -> _
     • Relevant bindings include
-        bar :: t1 -> (t1 -> t) -> t
+        bar :: t -> (t -> t1) -> t1
           (bound at WarningWildcardInstantiations.hs:9:1)
 
 WarningWildcardInstantiations.hs:8:18: warning: [-Wpartial-type-signatures (in -Wdefault)]
-    • Found type wildcard ‘_’ standing for ‘t’
-      Where: ‘t’ is a rigid type variable bound by
-               the inferred type of bar :: t1 -> (t1 -> t) -> t
+    • Found type wildcard ‘_’ standing for ‘t1
+      Where: ‘t1’ is a rigid type variable bound by
+               the inferred type of bar :: t -> (t -> t1) -> t1
                at WarningWildcardInstantiations.hs:9:1
     • In the type signature:
         bar :: _ -> _ -> _
     • Relevant bindings include
-        bar :: t1 -> (t1 -> t) -> t
+        bar :: t -> (t -> t1) -> t1
           (bound at WarningWildcardInstantiations.hs:9:1)
index 42218b5..d6a3a5a 100644 (file)
@@ -1,10 +1,10 @@
 
 T10045.hs:6:18: error:
-    • Found type wildcard ‘_’ standing for ‘t1 -> Bool -> t2
-      Where: ‘t2’ is a rigid type variable bound by
-               the inferred type of copy :: t1 -> Bool -> t2 at T10045.hs:7:10
-             ‘t1’ is a rigid type variable bound by
-               the inferred type of copy :: t1 -> Bool -> t2 at T10045.hs:7:10
+    • Found type wildcard ‘_’ standing for ‘t2 -> Bool -> t1
+      Where: ‘t1’ is a rigid type variable bound by
+               the inferred type of copy :: t2 -> Bool -> t1 at T10045.hs:7:10
+             ‘t2’ is a rigid type variable bound by
+               the inferred type of copy :: t2 -> Bool -> t1 at T10045.hs:7:10
       To use the inferred type, enable PartialTypeSignatures
     • In the type signature:
         copy :: _
@@ -20,6 +20,6 @@ T10045.hs:6:18: error:
                 copy w from = copy w True
               in copy ws1 False
     • Relevant bindings include
-        copy :: t1 -> Bool -> t2 (bound at T10045.hs:7:10)
+        copy :: t2 -> Bool -> t1 (bound at T10045.hs:7:10)
         ws1 :: () (bound at T10045.hs:5:11)
         foo :: Meta -> t (bound at T10045.hs:5:1)
index ff18935..63058a9 100644 (file)
@@ -25,40 +25,40 @@ WildcardInstantiations.hs:5:30: error:
         foo :: a -> String (bound at WildcardInstantiations.hs:6:1)
 
 WildcardInstantiations.hs:8:8: error:
-    • Found type wildcard ‘_’ standing for ‘t1
-      Where: ‘t1’ is a rigid type variable bound by
-               the inferred type of bar :: t1 -> (t1 -> t) -> t
+    • Found type wildcard ‘_’ standing for ‘t’
+      Where: ‘t’ is a rigid type variable bound by
+               the inferred type of bar :: t -> (t -> t1) -> t1
                at WildcardInstantiations.hs:9:1
       To use the inferred type, enable PartialTypeSignatures
     • In the type signature:
         bar :: _ -> _ -> _
     • Relevant bindings include
-        bar :: t1 -> (t1 -> t) -> t
+        bar :: t -> (t -> t1) -> t1
           (bound at WildcardInstantiations.hs:9:1)
 
 WildcardInstantiations.hs:8:13: error:
-    • Found type wildcard ‘_’ standing for ‘t1 -> t
-      Where: ‘t’ is a rigid type variable bound by
-               the inferred type of bar :: t1 -> (t1 -> t) -> t
+    • Found type wildcard ‘_’ standing for ‘t -> t1
+      Where: ‘t1’ is a rigid type variable bound by
+               the inferred type of bar :: t -> (t -> t1) -> t1
                at WildcardInstantiations.hs:9:1
-             ‘t1’ is a rigid type variable bound by
-               the inferred type of bar :: t1 -> (t1 -> t) -> t
+             ‘t’ is a rigid type variable bound by
+               the inferred type of bar :: t -> (t -> t1) -> t1
                at WildcardInstantiations.hs:9:1
       To use the inferred type, enable PartialTypeSignatures
     • In the type signature:
         bar :: _ -> _ -> _
     • Relevant bindings include
-        bar :: t1 -> (t1 -> t) -> t
+        bar :: t -> (t -> t1) -> t1
           (bound at WildcardInstantiations.hs:9:1)
 
 WildcardInstantiations.hs:8:18: error:
-    • Found type wildcard ‘_’ standing for ‘t’
-      Where: ‘t’ is a rigid type variable bound by
-               the inferred type of bar :: t1 -> (t1 -> t) -> t
+    • Found type wildcard ‘_’ standing for ‘t1
+      Where: ‘t1’ is a rigid type variable bound by
+               the inferred type of bar :: t -> (t -> t1) -> t1
                at WildcardInstantiations.hs:9:1
       To use the inferred type, enable PartialTypeSignatures
     • In the type signature:
         bar :: _ -> _ -> _
     • Relevant bindings include
-        bar :: t1 -> (t1 -> t) -> t
+        bar :: t -> (t -> t1) -> t1
           (bound at WildcardInstantiations.hs:9:1)
index 88d8f84..7a0af54 100644 (file)
@@ -19,7 +19,7 @@ T11213.hs:23:1: warning: [-Wmissing-pattern-synonym-signatures (in -Wall)]
 
 T11213.hs:24:1: warning: [-Wmissing-pattern-synonym-signatures (in -Wall)]
     Top-level binding with no type signature:
-      Purp :: forall a t.
+      Purp :: forall t a.
               (Num a, Eq a) =>
               Show t => a -> t -> ([a], UnivProv t)
 
index d3ed001..12d93fc 100644 (file)
@@ -1,19 +1,19 @@
 
 T7438.hs:6:14: error:
-    • Couldn't match expected type ‘t3’ with actual type ‘t2
-        ‘t3’ is untouchable
-          inside the constraints: t1 ~ t
+    • Couldn't match expected type ‘t2’ with actual type ‘t3
+        ‘t2’ is untouchable
+          inside the constraints: t ~ t1
           bound by a pattern with constructor:
                      Nil :: forall k (a :: k). Thrist a a,
                    in an equation for ‘go’
           at T7438.hs:6:4-6
-      ‘t3’ is a rigid type variable bound by
-        the inferred type of go :: Thrist t t1 -> t2 -> t3 at T7438.hs:6:1
       ‘t2’ is a rigid type variable bound by
-        the inferred type of go :: Thrist t t1 -> t2 -> t3 at T7438.hs:6:1
+        the inferred type of go :: Thrist t1 t -> t3 -> t2 at T7438.hs:6:1
+      ‘t3’ is a rigid type variable bound by
+        the inferred type of go :: Thrist t1 t -> t3 -> t2 at T7438.hs:6:1
       Possible fix: add a type signature for ‘go’
     • In the expression: acc
       In an equation for ‘go’: go Nil acc = acc
     • Relevant bindings include
-        acc :: t2 (bound at T7438.hs:6:8)
-        go :: Thrist t t1 -> t2 -> t3 (bound at T7438.hs:6:1)
+        acc :: t3 (bound at T7438.hs:6:8)
+        go :: Thrist t1 t -> t3 -> t2 (bound at T7438.hs:6:1)
index 2340ce1..c096719 100644 (file)
@@ -2,5 +2,5 @@
 T7524.hs:5:15: error:
     Conflicting family instance declarations:
       forall k2 (a :: k2). F a a = Int -- Defined at T7524.hs:5:15
-      forall k2 k1 (a :: k1) (b :: k2).
+      forall k2 k1 (b :: k2) (a :: k1).
         F a b = Bool -- Defined at T7524.hs:6:15
index 4cae65a..4baecc2 100644 (file)
@@ -1,4 +1,4 @@
 
 T2993.hs:7:13: error:
-    • Variable not in scope: (<**>) :: t -> (b -> b) -> t1
+    • Variable not in scope: (<**>) :: t1 -> (b -> b) -> t
     • Perhaps you meant ‘<*>’ (imported from Prelude)
index 0702b32..72c675a 100644 (file)
@@ -11,7 +11,7 @@ T10971a.hs:7:11: warning: [-Wtype-defaults (in -Wall)]
 
 T10971a.hs:8:1: warning: [-Wmissing-signatures (in -Wall)]
     Top-level binding with no type signature:
-      g :: forall a b. (a -> b) -> [a] -> [b]
+      g :: forall b a. (a -> b) -> [a] -> [b]
 
 T10971a.hs:8:6: warning: [-Wname-shadowing (in -Wall)]
     This binding for ‘f’ shadows the existing binding
index 15bdad8..49a26d6 100644 (file)
@@ -35,7 +35,7 @@ tc141.hs:13:13: error:
         in v
 
 tc141.hs:15:18: error:
-    • Couldn't match expected type ‘a1’ with actual type ‘t1
+    • Couldn't match expected type ‘a1’ with actual type ‘t’
         because type variable ‘a1’ would escape its scope
       This (rigid, skolem) type variable is bound by
         the type signature for:
@@ -50,5 +50,5 @@ tc141.hs:15:18: error:
         in v
     • Relevant bindings include
         v :: a1 (bound at tc141.hs:15:14)
-        b :: t1 (bound at tc141.hs:13:5)
-        g :: t -> t1 -> forall a. a (bound at tc141.hs:13:1)
+        b :: t (bound at tc141.hs:13:5)
+        g :: t1 -> t -> forall a. a (bound at tc141.hs:13:1)
index 16ba4b0..5bcce5b 100644 (file)
@@ -9,4 +9,4 @@ tc168.hs:17:1: error:
     • In the ambiguity check for the inferred type for ‘g’
       To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
       When checking the inferred type
-        g :: forall a b a1. C a1 (a, b) => a1 -> a
+        g :: forall b a a1. C a1 (a, b) => a1 -> a
index dd56248..daa77b3 100644 (file)
@@ -2,7 +2,7 @@ TYPE SIGNATURES
   Node :: forall s a chain. s -> a -> chain -> Q s a chain
   Z :: forall a. a -> Z a
   foo ::
-    forall s b chain.
+    forall chain s b.
     Zork s (Z [Char]) b =>
     Q s (Z [Char]) chain -> ST s ()
   huh ::
index d9a8244..c95dc53 100644 (file)
@@ -1,23 +1,23 @@
 
 T5853.hs:15:46: error:
-    • Could not deduce: Subst t1 (Elem t2) ~ t2
+    • Could not deduce: Subst t (Elem t2) ~ t2
         arising from a use of ‘<$>’
-      from the context: (F t,
-                         Elem t ~ Elem t,
-                         Elem t2 ~ Elem t2,
-                         Subst t (Elem t2) ~ t2,
-                         Subst t2 (Elem t) ~ t,
-                         F t1,
+      from the context: (F t1,
                          Elem t1 ~ Elem t1,
+                         Elem t2 ~ Elem t2,
+                         Subst t1 (Elem t2) ~ t2,
+                         Subst t2 (Elem t1) ~ t1,
+                         F t,
                          Elem t ~ Elem t,
-                         Subst t1 (Elem t) ~ t,
-                         Subst t (Elem t1) ~ t1)
+                         Elem t1 ~ Elem t1,
+                         Subst t (Elem t1) ~ t1,
+                         Subst t1 (Elem t) ~ t)
         bound by the RULE "map/map" at T5853.hs:15:2-57
       ‘t2’ is a rigid type variable bound by
         the RULE "map/map" at T5853.hs:15:2
     • In the expression: (f . g) <$> xs
       When checking the transformation rule "map/map"
     • Relevant bindings include
-        f :: Elem t -> Elem t2 (bound at T5853.hs:15:19)
-        g :: Elem t1 -> Elem t (bound at T5853.hs:15:21)
-        xs :: t1 (bound at T5853.hs:15:23)
+        f :: Elem t1 -> Elem t2 (bound at T5853.hs:15:19)
+        g :: Elem t -> Elem t1 (bound at T5853.hs:15:21)
+        xs :: t (bound at T5853.hs:15:23)
index c20c9ec..3bd6b40 100644 (file)
@@ -79,7 +79,7 @@ T6018fail.hs:66:15: error:
     Kind variable ‘k’ cannot be inferred from the right-hand side.
     Use -fprint-explicit-kinds to see the kind arguments
     In the type family equation:
-      forall k (a :: k) (b :: k).
+      forall k (b :: k) (a :: k).
         Fc a b = Int -- Defined at T6018fail.hs:66:15
 
 T6018fail.hs:70:15: error:
@@ -88,7 +88,7 @@ T6018fail.hs:70:15: error:
     cannot be inferred from the right-hand side.
     Use -fprint-explicit-kinds to see the kind arguments
     In the type family equation:
-      forall k (a :: k) (b :: k).
+      forall k (b :: k) (a :: k).
         Gc a b = Int -- Defined at T6018fail.hs:70:15
 
 T6018fail.hs:74:15: error:
@@ -145,7 +145,7 @@ T6018fail.hs:118:15: error:
     cannot be inferred from the right-hand side.
     Use -fprint-explicit-kinds to see the kind arguments
     In the type family equation:
-      forall k a b (c :: k).
+      forall k (c :: k) b a.
         G7 a b c = [G7a a b c] -- Defined at T6018fail.hs:118:15
 
 T6018fail.hs:129:1: error:
index 6cc0c37..7a0146d 100644 (file)
@@ -24,11 +24,11 @@ T6018failclosed.hs:19:5: error:
 
 T6018failclosed.hs:25:5: error:
     • Type family equation violates injectivity annotation.
-      Type and kind variables ‘k’, ‘b’
+      Type and kind variables ‘k1’, ‘b’
       cannot be inferred from the right-hand side.
       Use -fprint-explicit-kinds to see the kind arguments
       In the type family equation:
-        forall k k1 (b :: k) (c :: k1).
+        forall k k1 (c :: k) (b :: k1).
           JClosed Int b c = Char -- Defined at T6018failclosed.hs:25:5
     • In the equations for closed type family ‘JClosed’
       In the type family declaration for ‘JClosed’
@@ -90,7 +90,7 @@ T6018failclosed.hs:66:5: error:
       Kind variable ‘k’ cannot be inferred from the right-hand side.
       Use -fprint-explicit-kinds to see the kind arguments
       In the type family equation:
-        forall k (a :: k) (b :: k).
+        forall k (b :: k) (a :: k).
           Gc a b = Int -- Defined at T6018failclosed.hs:66:5
     • In the equations for closed type family ‘Gc’
       In the type family declaration for ‘Gc’
index bcb2df8..6b8e920 100644 (file)
@@ -28,14 +28,14 @@ T7453.hs:9:15: error:
         cast1 :: t -> a (bound at T7453.hs:7:1)
 
 T7453.hs:15:15: error:
-    • Couldn't match type ‘t’ with ‘t2’
+    • Couldn't match type ‘t1’ with ‘t2’
         because type variable ‘t2’ would escape its scope
       This (rigid, skolem) type variable is bound by
         the type signature for:
           z :: () -> t2
         at T7453.hs:14:11-22
       Expected type: () -> t2
-        Actual type: () -> t
+        Actual type: () -> t1
     • In the expression: aux
       In an equation for ‘z’:
           z = aux
@@ -50,13 +50,13 @@ T7453.hs:15:15: error:
                   where
                       aux = const v
     • Relevant bindings include
-        aux :: forall b. b -> t (bound at T7453.hs:16:21)
+        aux :: forall b. b -> t1 (bound at T7453.hs:16:21)
         z :: () -> t2 (bound at T7453.hs:15:11)
-        v :: t (bound at T7453.hs:13:7)
-        cast2 :: t -> t1 (bound at T7453.hs:13:1)
+        v :: t1 (bound at T7453.hs:13:7)
+        cast2 :: t1 -> t (bound at T7453.hs:13:1)
 
 T7453.hs:21:15: error:
-    • Couldn't match expected type ‘t2’ with actual type ‘t’
+    • Couldn't match expected type ‘t2’ with actual type ‘t1
         because type variable ‘t2’ would escape its scope
       This (rigid, skolem) type variable is bound by
         the type signature for:
@@ -76,7 +76,7 @@ T7453.hs:21:15: error:
                   where
                       aux = const v
     • Relevant bindings include
-        aux :: forall b. b -> t (bound at T7453.hs:22:21)
+        aux :: forall b. b -> t1 (bound at T7453.hs:22:21)
         z :: t2 (bound at T7453.hs:21:11)
-        v :: t (bound at T7453.hs:19:7)
-        cast3 :: t -> forall t1. t1 (bound at T7453.hs:19:1)
+        v :: t1 (bound at T7453.hs:19:7)
+        cast3 :: t1 -> forall t. t (bound at T7453.hs:19:1)
index 1b1716b..8553fdb 100644 (file)
@@ -1,18 +1,18 @@
 
 T7734.hs:4:13: error:
-    • Occurs check: cannot construct the infinite type: t1 ~ t1 -> t2
+    • Occurs check: cannot construct the infinite type: t2 ~ t2 -> t1
     • In the first argument of ‘x’, namely ‘x’
       In the expression: x x
       In an equation for ‘f’: x `f` y = x x
     • Relevant bindings include
-        x :: t1 -> t2 (bound at T7734.hs:4:1)
-        f :: (t1 -> t2) -> t -> t2 (bound at T7734.hs:4:3)
+        x :: t2 -> t1 (bound at T7734.hs:4:1)
+        f :: (t2 -> t1) -> t -> t1 (bound at T7734.hs:4:3)
 
 T7734.hs:5:13: error:
-    • Occurs check: cannot construct the infinite type: t1 ~ t1 -> t2
+    • Occurs check: cannot construct the infinite type: t2 ~ t2 -> t1
     • In the first argument of ‘x’, namely ‘x’
       In the expression: x x
       In an equation for ‘&’: (&) x y = x x
     • Relevant bindings include
-        x :: t1 -> t2 (bound at T7734.hs:5:5)
-        (&) :: (t1 -> t2) -> t -> t2 (bound at T7734.hs:5:1)
+        x :: t2 -> t1 (bound at T7734.hs:5:5)
+        (&) :: (t2 -> t1) -> t -> t1 (bound at T7734.hs:5:1)
index 3faa530..53e6798 100644 (file)
@@ -8,7 +8,7 @@ T8142.hs:6:18: error:
     • In the ambiguity check for the inferred type for ‘h’
       To defer the ambiguity check to use sites, enable AllowAmbiguousTypes
       When checking the inferred type
-        h :: forall t (g :: * -> *). Nu ((,) t) -> Nu g
+        h :: forall (g :: * -> *) t. Nu ((,) t) -> Nu g
       In an equation for ‘tracer’:
           tracer
             = h
index 6a08318..71d88ef 100644 (file)
@@ -1,15 +1,15 @@
 
 T9109.hs:8:13: error:
-    • Couldn't match expected type ‘t1’ with actual type ‘Bool’
-        ‘t1’ is untouchable
-          inside the constraints: t ~ Bool
+    • Couldn't match expected type ‘t’ with actual type ‘Bool’
+        ‘t’ is untouchable
+          inside the constraints: t1 ~ Bool
           bound by a pattern with constructor: GBool :: G Bool,
                    in an equation for ‘foo’
           at T9109.hs:8:5-9
-      ‘t1’ is a rigid type variable bound by
-        the inferred type of foo :: G t -> t1 at T9109.hs:8:1
+      ‘t’ is a rigid type variable bound by
+        the inferred type of foo :: G t1 -> t at T9109.hs:8:1
       Possible fix: add a type signature for ‘foo’
     • In the expression: True
       In an equation for ‘foo’: foo GBool = True
     • Relevant bindings include
-        foo :: G t -> t1 (bound at T9109.hs:8:1)
+        foo :: G t1 -> t (bound at T9109.hs:8:1)
index c575129..41a55c1 100644 (file)
@@ -1,9 +1,9 @@
 
 tcfail004.hs:3:9: error:
-    • Couldn't match expected type ‘(t, t1)’
+    • Couldn't match expected type ‘(t1, t)’
                   with actual type ‘(Integer, Integer, Integer)’
     • In the expression: (1, 2, 3)
       In a pattern binding: (f, g) = (1, 2, 3)
     • Relevant bindings include
-        f :: t (bound at tcfail004.hs:3:2)
-        g :: t1 (bound at tcfail004.hs:3:4)
+        f :: t1 (bound at tcfail004.hs:3:2)
+        g :: t (bound at tcfail004.hs:3:4)
index 94e998f..e349ab1 100644 (file)
@@ -1,10 +1,10 @@
 
 tcfail033.hs:4:12: error:
-    • Occurs check: cannot construct the infinite type: t ~ (t, t1)
+    • Occurs check: cannot construct the infinite type: t1 ~ (t1, t)
     • In the expression: x
       In the expression: [x | (x, y) <- buglet]
       In an equation for ‘buglet’: buglet = [x | (x, y) <- buglet]
     • Relevant bindings include
-        y :: t1 (bound at tcfail033.hs:4:19)
-        x :: t (bound at tcfail033.hs:4:17)
-        buglet :: [(t, t1)] (bound at tcfail033.hs:4:1)
+        y :: t (bound at tcfail033.hs:4:19)
+        x :: t1 (bound at tcfail033.hs:4:17)
+        buglet :: [(t1, t)] (bound at tcfail033.hs:4:1)
index 1b74ce0..ec83902 100644 (file)
@@ -1,2 +1,2 @@
 
-tcfail049.hs:3:7: error: Variable not in scope: g :: t -> t1
+tcfail049.hs:3:7: error: Variable not in scope: g :: t1 -> t
index 2ca5065..9d6a0c0 100644 (file)
@@ -1,3 +1,3 @@
 
 tcfail050.hs:3:7: error:
-    Data constructor not in scope: B :: t -> t1
+    Data constructor not in scope: B :: t1 -> t
index 4c3fece..f75f77c 100644 (file)
@@ -9,14 +9,14 @@ tcfail140.hs:10:7: error:
     • Relevant bindings include bar :: t (bound at tcfail140.hs:10:1)
 
 tcfail140.hs:12:10: error:
-    • Couldn't match expected type ‘Integer -> t1
+    • Couldn't match expected type ‘Integer -> t’
                   with actual type ‘Int’
     • The operator ‘f’ takes two arguments,
       but its type ‘Int -> Int’ has only one
       In the expression: 3 `f` 4
       In an equation for ‘rot’: rot xs = 3 `f` 4
     • Relevant bindings include
-        rot :: t -> t1 (bound at tcfail140.hs:12:1)
+        rot :: t1 -> t (bound at tcfail140.hs:12:1)
 
 tcfail140.hs:14:15: error:
     • Couldn't match expected type ‘t -> b’ with actual type ‘Int’
index 8846993..51aaf1d 100644 (file)
@@ -1,6 +1,6 @@
 
 tcfail198.hs:6:36: error:
-    • Couldn't match expected type ‘a2’ with actual type ‘a1
+    • Couldn't match expected type ‘a2’ with actual type ‘a’
         because type variable ‘a2’ would escape its scope
       This (rigid, skolem) type variable is bound by
         an expression type signature:
@@ -10,6 +10,6 @@ tcfail198.hs:6:36: error:
       In the second argument of ‘(++)’, namely ‘[x :: a]’
       In the expression: xs ++ [x :: a]
     • Relevant bindings include
-        xs :: [a1] (bound at tcfail198.hs:6:21)
-        x :: a1 (bound at tcfail198.hs:6:19)
-        f3 :: [a1] -> [a1] (bound at tcfail198.hs:6:6)
+        xs :: [a] (bound at tcfail198.hs:6:21)
+        x :: a (bound at tcfail198.hs:6:19)
+        f3 :: [a] -> [a] (bound at tcfail198.hs:6:6)