Merge branch 'master' into wip/new-flatten-skolems-Aug14
authorSimon Peyton Jones <simonpj@microsoft.com>
Fri, 26 Sep 2014 13:57:23 +0000 (14:57 +0100)
committerSimon Peyton Jones <simonpj@microsoft.com>
Fri, 26 Sep 2014 13:57:23 +0000 (14:57 +0100)
Conflicts:
compiler/typecheck/Inst.lhs
compiler/typecheck/TcMType.lhs
compiler/typecheck/TcRnTypes.lhs
compiler/typecheck/TcSimplify.lhs
compiler/typecheck/TcUnify.lhs
testsuite/tests/indexed-types/should_compile/T3017.stderr
testsuite/tests/indexed-types/should_fail/T7729.stderr
testsuite/tests/indexed-types/should_fail/T8227.stderr
testsuite/tests/indexed-types/should_fail/T8518.stderr

15 files changed:
1  2 
compiler/typecheck/Inst.lhs
compiler/typecheck/TcErrors.lhs
compiler/typecheck/TcHsType.lhs
compiler/typecheck/TcInteract.lhs
compiler/typecheck/TcMType.lhs
compiler/typecheck/TcRnMonad.lhs
compiler/typecheck/TcRnTypes.lhs
compiler/typecheck/TcRules.lhs
compiler/typecheck/TcSMonad.lhs
compiler/typecheck/TcSimplify.lhs
compiler/typecheck/TcType.lhs
testsuite/tests/indexed-types/should_compile/T3017.stderr
testsuite/tests/indexed-types/should_fail/T7729.stderr
testsuite/tests/indexed-types/should_fail/T8227.stderr
testsuite/tests/indexed-types/should_fail/T8518.stderr

@@@ -525,10 -522,10 +521,10 @@@ tyVarsOfWC (WC { wc_flat = flat, wc_imp
  
  tyVarsOfImplic :: Implication -> TyVarSet
  -- Only called on *zonked* things, hence no need to worry about flatten-skolems
 -tyVarsOfImplic (Implic { ic_skols = skols, ic_fsks = fsks
 -                             , ic_given = givens, ic_wanted = wanted })
 +tyVarsOfImplic (Implic { ic_skols = skols
 +                       , ic_given = givens, ic_wanted = wanted })
    = (tyVarsOfWC wanted `unionVarSet` tyVarsOfTypes (map evVarPred givens))
-     `delVarSetList` skols 
 -    `delVarSetList` skols `delVarSetList` fsks
++    `delVarSetList` skols
  
  tyVarsOfBag :: (a -> TyVarSet) -> Bag a -> TyVarSet
  tyVarsOfBag tvs_of = foldrBag (unionVarSet . tvs_of) emptyVarSet
@@@ -1403,14 -1401,14 +1402,15 @@@ relevantBindings want_filtering ctxt c
         = return (tidy_env, reverse docs, discards)
      go tidy_env n_left tvs_seen docs discards (TcIdBndr id top_lvl : tc_bndrs)
         = do { (tidy_env', tidy_ty) <- zonkTidyTcType tidy_env (idType id)
+             ; traceTc "relevantBindings 1" (ppr id <+> dcolon <+> ppr tidy_ty)
              ; let id_tvs = tyVarsOfType tidy_ty
                    doc = sep [ pprPrefixOcc id <+> dcolon <+> ppr tidy_ty
-                           , nest 2 (parens (ptext (sLit "bound at")
-                                <+> ppr (getSrcLoc id)))]
+                             , nest 2 (parens (ptext (sLit "bound at")
+                                  <+> ppr (getSrcLoc id)))]
                    new_seen = tvs_seen `unionVarSet` id_tvs
  
 -            ; if (want_filtering && id_tvs `disjointVarSet` ct_tvs)
 +            ; if (want_filtering && not opt_PprStyle_Debug 
 +                                 && id_tvs `disjointVarSet` ct_tvs)
                         -- We want to filter out this binding anyway
                         -- so discard it silently
                then go tidy_env n_left tvs_seen docs discards tc_bndrs
Simple merge
Simple merge
@@@ -1,4 -1,4 +1,4 @@@
--o%
++%
  % (c) The University of Glasgow 2006
  % (c) The GRASP/AQUA Project, Glasgow University, 1992-1998
  %
@@@ -314,15 -309,14 +308,15 @@@ instead of the buggou
  newMetaTyVar :: MetaInfo -> Kind -> TcM TcTyVar
  -- Make a new meta tyvar out of thin air
  newMetaTyVar meta_info kind
-   = do        { uniq <- newUnique
+   = do  { uniq <- newUnique
          ; let name = mkTcTyVarName uniq s
                s = case meta_info of
 -                        PolyTv -> fsLit "s"
 -                        TauTv  -> fsLit "t"
 -                        SigTv  -> fsLit "a"
 +                        PolyTv     -> fsLit "s"
 +                        TauTv      -> fsLit "t"
 +                        FlatMetaTv -> fsLit "fu"
 +                        SigTv      -> fsLit "a"
          ; details <- newMetaDetails meta_info
-       ; return (mkTcTyVar name kind details) }
+         ; return (mkTcTyVar name kind details) }
  
  cloneMetaTyVar :: TcTyVar -> TcM TcTyVar
  cloneMetaTyVar tv
@@@ -740,10 -733,11 +734,10 @@@ zonkImplication implic@(Implic { ic_unt
         ; given'  <- mapM zonkEvVar given
         ; info'   <- zonkSkolemInfo info
         ; wanted' <- zonkWCRec binds_var untch wanted
-        ; if isEmptyWC wanted' 
+        ; if isEmptyWC wanted'
           then return emptyBag
           else return $ unitBag $
 -              implic { ic_fsks   = []  -- Zonking removes all FlatSkol tyvars
 -                     , ic_skols  = skols'
 +              implic { ic_skols  = skols'
                       , ic_given  = given'
                       , ic_wanted = wanted'
                       , ic_info   = info' } }
@@@ -771,17 -765,14 +765,17 @@@ zonkWCRec binds_var untch (WC { wc_fla
  zonkFlats :: EvBindsVar -> Untouchables -> Cts -> TcM Cts
  -- This zonks and unflattens a bunch of flat constraints
  -- See Note [Unflattening while zonking]
 -zonkFlats binds_var untch cts
 +zonkFlats _binds_var _untch cts
    = do { -- See Note [How to unflatten]
 -         cts <- foldrBagM unflatten_one emptyCts cts
 +--         cts <- foldrBagM unflatten_one emptyCts cts
         ; zonkCts cts }
 +{-
    where
      unflatten_one orig_ct cts
 -      = do { zct <- zonkCt orig_ct                -- First we need to fully zonk
 +      = do { traceTc "unflatten {" (ppr orig_ct)
-            ; zct <- zonkCt orig_ct                -- First we need to fully zonk 
++           ; zct <- zonkCt orig_ct                -- First we need to fully zonk
             ; mct <- try_zonk_fun_eq orig_ct zct   -- Then try to solve if family equation
 +           ; traceTc "unflatten }" (ppr mct)
             ; return $ maybe cts (`consBag` cts) mct }
  
      try_zonk_fun_eq orig_ct zct   -- See Note [How to unflatten]
Simple merge
@@@ -1831,52 -1836,84 +1838,83 @@@ data CtOrigi
    | UnboundOccurrenceOf RdrName
    | ListOrigin          -- An overloaded list
  
- pprO :: CtOrigin -> SDoc
- pprO (GivenOrigin sk)      = ppr sk
- pprO (OccurrenceOf name)   = hsep [ptext (sLit "a use of"), quotes (ppr name)]
- pprO AppOrigin             = ptext (sLit "an application")
- pprO (SpecPragOrigin name) = hsep [ptext (sLit "a specialisation pragma for"), quotes (ppr name)]
- pprO (IPOccOrigin name)    = hsep [ptext (sLit "a use of implicit parameter"), quotes (ppr name)]
- pprO RecordUpdOrigin       = ptext (sLit "a record update")
- pprO (AmbigOrigin ctxt)    = ptext (sLit "the ambiguity check for")
-                              <+> case ctxt of
-                                     FunSigCtxt name -> quotes (ppr name)
-                                     InfSigCtxt name -> quotes (ppr name)
-                                     _               -> pprUserTypeCtxt ctxt
- pprO ExprSigOrigin         = ptext (sLit "an expression type signature")
- pprO PatSigOrigin          = ptext (sLit "a pattern type signature")
- pprO PatOrigin             = ptext (sLit "a pattern")
- pprO ViewPatOrigin         = ptext (sLit "a view pattern")
- pprO IfOrigin              = ptext (sLit "an if statement")
- pprO (LiteralOrigin lit)   = hsep [ptext (sLit "the literal"), quotes (ppr lit)]
- pprO (ArithSeqOrigin seq)  = hsep [ptext (sLit "the arithmetic sequence"), quotes (ppr seq)]
- pprO (PArrSeqOrigin seq)   = hsep [ptext (sLit "the parallel array sequence"), quotes (ppr seq)]
- pprO SectionOrigin         = ptext (sLit "an operator section")
- pprO TupleOrigin           = ptext (sLit "a tuple")
- pprO NegateOrigin          = ptext (sLit "a use of syntactic negation")
- pprO ScOrigin              = ptext (sLit "the superclasses of an instance declaration")
- pprO DerivOrigin           = ptext (sLit "the 'deriving' clause of a data type declaration")
- pprO (DerivOriginDC dc n)  = hsep [ ptext (sLit "the"), speakNth n,
-                                     ptext (sLit "field of"), quotes (ppr dc),
-                                     parens (ptext (sLit "type") <+> quotes (ppr ty)) ]
-     where ty = dataConOrigArgTys dc !! (n-1)
- pprO (DerivOriginCoerce meth ty1 ty2)
-                            = sep [ ptext (sLit "the coercion of the method") <+> quotes (ppr meth)
-                                  , ptext (sLit "from type") <+> quotes (ppr ty1)
-                                  , nest 2 (ptext (sLit "to type") <+> quotes (ppr ty2)) ]
- pprO StandAloneDerivOrigin = ptext (sLit "a 'deriving' declaration")
- pprO DefaultOrigin         = ptext (sLit "a 'default' declaration")
- pprO DoOrigin              = ptext (sLit "a do statement")
- pprO MCompOrigin           = ptext (sLit "a statement in a monad comprehension")
- pprO ProcOrigin            = ptext (sLit "a proc expression")
- pprO (TypeEqOrigin t1 t2)  = ptext (sLit "a type equality") <+> sep [ppr t1, char '~', ppr t2]
- pprO (KindEqOrigin t1 t2 _) = ptext (sLit "a kind equality arising from") <+> sep [ppr t1, char '~', ppr t2]
- pprO AnnOrigin             = ptext (sLit "an annotation")
- pprO FunDepOrigin          = ptext (sLit "a functional dependency")
- pprO HoleOrigin            = ptext (sLit "a use of") <+> quotes (ptext $ sLit "_")
- pprO (UnboundOccurrenceOf name) = hsep [ptext (sLit "an undeclared identifier"), quotes (ppr name)]
- pprO ListOrigin            = ptext (sLit "an overloaded list")
--
- instance Outputable CtOrigin where
-   ppr = pprO
+ ctoHerald :: SDoc
+ ctoHerald = ptext (sLit "arising from")
+ pprCtOrigin :: CtOrigin -> SDoc
+ pprCtOrigin (GivenOrigin sk) = ctoHerald <+> ppr sk
+ pprCtOrigin (FunDepOrigin1 pred1 loc1 pred2 loc2)
+   = hang (ctoHerald <+> ptext (sLit "a functional dependency between constraints:"))
+        2 (vcat [ hang (quotes (ppr pred1)) 2 (pprArisingAt loc1)
+                , hang (quotes (ppr pred2)) 2 (pprArisingAt loc2) ])
+ pprCtOrigin (FunDepOrigin2 pred1 orig1 pred2 loc2)
+   = hang (ctoHerald <+> ptext (sLit "a functional dependency between:"))
+        2 (vcat [ hang (ptext (sLit "constraint") <+> quotes (ppr pred1))
+                     2 (pprArising orig1 )
+                , hang (ptext (sLit "instance") <+> quotes (ppr pred2))
+                     2 (ptext (sLit "at") <+> ppr loc2) ])
+ pprCtOrigin (KindEqOrigin t1 t2 _)
+   = hang (ctoHerald <+> ptext (sLit "a kind equality arising from"))
+        2 (sep [ppr t1, char '~', ppr t2])
+ pprCtOrigin (UnboundOccurrenceOf name)
+   = ctoHerald <+> ptext (sLit "an undeclared identifier") <+> quotes (ppr name)
+ pprCtOrigin (DerivOriginDC dc n)
+   = hang (ctoHerald <+> ptext (sLit "the") <+> speakNth n
+           <+> ptext (sLit "field of") <+> quotes (ppr dc))
+        2 (parens (ptext (sLit "type") <+> quotes (ppr ty)))
+   where
+     ty = dataConOrigArgTys dc !! (n-1)
+ pprCtOrigin (AmbigOrigin ctxt)
+   = ctoHerald <+> ptext (sLit "the ambiguity check for")
+     <+> case ctxt of
+            FunSigCtxt name -> quotes (ppr name)
+            InfSigCtxt name -> quotes (ppr name)
+            _               -> pprUserTypeCtxt ctxt
+ pprCtOrigin (DerivOriginCoerce meth ty1 ty2)
+   = hang (ctoHerald <+> ptext (sLit "the coercion of the method") <+> quotes (ppr meth))
+        2 (sep [ ptext (sLit "from type") <+> quotes (ppr ty1)
+               , ptext (sLit "  to type") <+> quotes (ppr ty2) ])
+ pprCtOrigin simple_origin
+   = ctoHerald <+> pprCtO simple_origin
+ ----------------
+ pprCtO :: CtOrigin -> SDoc  -- Ones that are short one-liners
+ pprCtO FlatSkolOrigin        = ptext (sLit "a given flatten-skolem")
+ pprCtO (OccurrenceOf name)   = hsep [ptext (sLit "a use of"), quotes (ppr name)]
+ pprCtO AppOrigin             = ptext (sLit "an application")
+ pprCtO (SpecPragOrigin name) = hsep [ptext (sLit "a specialisation pragma for"), quotes (ppr name)]
+ pprCtO (IPOccOrigin name)    = hsep [ptext (sLit "a use of implicit parameter"), quotes (ppr name)]
+ pprCtO RecordUpdOrigin       = ptext (sLit "a record update")
+ pprCtO ExprSigOrigin         = ptext (sLit "an expression type signature")
+ pprCtO PatSigOrigin          = ptext (sLit "a pattern type signature")
+ pprCtO PatOrigin             = ptext (sLit "a pattern")
+ pprCtO ViewPatOrigin         = ptext (sLit "a view pattern")
+ pprCtO IfOrigin              = ptext (sLit "an if statement")
+ pprCtO (LiteralOrigin lit)   = hsep [ptext (sLit "the literal"), quotes (ppr lit)]
+ pprCtO (ArithSeqOrigin seq)  = hsep [ptext (sLit "the arithmetic sequence"), quotes (ppr seq)]
+ pprCtO (PArrSeqOrigin seq)   = hsep [ptext (sLit "the parallel array sequence"), quotes (ppr seq)]
+ pprCtO SectionOrigin         = ptext (sLit "an operator section")
+ pprCtO TupleOrigin           = ptext (sLit "a tuple")
+ pprCtO NegateOrigin          = ptext (sLit "a use of syntactic negation")
+ pprCtO ScOrigin              = ptext (sLit "the superclasses of an instance declaration")
+ pprCtO DerivOrigin           = ptext (sLit "the 'deriving' clause of a data type declaration")
+ pprCtO StandAloneDerivOrigin = ptext (sLit "a 'deriving' declaration")
+ pprCtO DefaultOrigin         = ptext (sLit "a 'default' declaration")
+ pprCtO DoOrigin              = ptext (sLit "a do statement")
+ pprCtO MCompOrigin           = ptext (sLit "a statement in a monad comprehension")
+ pprCtO ProcOrigin            = ptext (sLit "a proc expression")
+ pprCtO (TypeEqOrigin t1 t2)  = ptext (sLit "a type equality") <+> sep [ppr t1, char '~', ppr t2]
+ pprCtO AnnOrigin             = ptext (sLit "an annotation")
+ pprCtO HoleOrigin            = ptext (sLit "a use of") <+> quotes (ptext $ sLit "_")
+ pprCtO ListOrigin            = ptext (sLit "an overloaded list")
+ pprCtO _                     = panic "pprCtOrigin"
  \end{code}
Simple merge
@@@ -126,8 -122,8 +126,9 @@@ import Nam
  import RdrName (RdrName, GlobalRdrEnv)
  import RnEnv (addUsedRdrNames)
  import Var
+ import VarSet
  import VarEnv
 +import VarSet
  import Outputable
  import Bag
  import MonadUtils
@@@ -683,23 -697,12 +684,26 @@@ solveWanteds wanted
         ; bb <- getTcEvBindsMap
         ; tb <- getTcSTyBindsMap
         ; traceTcS "solveWanteds }" $
 -                 vcat [ text "unsolved_flats   =" <+> ppr unsolved_flats
 -                      , text "unsolved_implics =" <+> ppr unsolved_implics
 +                 vcat [ text "final wc =" <+> ppr final_wanteds
                        , text "current evbinds  =" <+> ppr (evBindMapBinds bb)
 -                      , text "current tybinds  =" <+> vcat (map ppr (varEnvElts tb))
 -                      , text "final wc =" <+> ppr wc ]
 -
 +                      , text "current tybinds  =" <+> vcat (map ppr (varEnvElts tb)) ]
 +
 +       ; return final_wanteds }
 +
 +solveFlats :: WantedConstraints -> TcS WantedConstraints
 +-- Solve the wc_flat and wc_insol components of the WantedConstraints
 +-- Do not affect the inerts
 +solveFlats (WC { wc_flat = flats, wc_insol = insols, wc_impl = implics })
 +  = do { (wc, given_funeqs) <- nestTcS $
-             do { implics_from_flats <- solveInteract (flats `unionBags` insols)
++            do { let all_flats = flats `unionBags` filterBag (not . isDerivedCt) insols
++                     -- See Note [Dropping derived constraints] in TcRnTypes for
++                     -- why the insolubles may have derived constraints
++               ; implics_from_flats <- solveInteract all_flats
 +               ; (unsolved_flats, insoluble_flats, given_funeqs) <- getInertUnsolved
 +               ; return ( WC { wc_flat = unsolved_flats, wc_insol = insoluble_flats
 +                             , wc_impl = implics `unionBags` implics_from_flats }
 +                        , given_funeqs ) }
 +       ; setInertFunEqs given_funeqs
         ; return wc }
  
  simpl_loop :: Int
@@@ -1144,14 -1139,15 +1148,15 @@@ floatEqualities :: [TcTyVar] -> Boo
  --
  -- Subtleties: Note [Float equalities from under a skolem binding]
  --             Note [Skolem escape]
 -floatEqualities skols no_given_eqs wanteds@(WC { wc_flat = flats, wc_insol = insols })
 +floatEqualities skols no_given_eqs
-                 wanteds@(WC { wc_flat = flats })
++                wanteds@(WC { wc_flat = flats, wc_insol = insols })
    | not no_given_eqs  -- There are some given equalities, so don't float
    = return (emptyBag, wanteds)   -- Note [Float Equalities out of Implications]
+   | not (isEmptyBag insols)
+   = return (emptyBag, wanteds)   -- Note [Do not float equalities if there are insolubles]
    | otherwise
 -  = do { let (float_eqs, remaining_flats) = partitionBag is_floatable flats
 -       ; untch <- TcS.getUntouchables
 -       ; mapM_ (promoteTyVar untch) (varSetElems (tyVarsOfCts float_eqs))
 +  = do { outer_untch <- TcS.getUntouchables
 +       ; mapM_ (promoteTyVar outer_untch) (varSetElems (tyVarsOfCts float_eqs))
               -- See Note [Promoting unification variables]
         ; ty_binds <- getTcSTyBindsMap
         ; traceTcS "floatEqualities" (vcat [ text "Skols =" <+> ppr skols
                                            , text "Ty binds =" <+> ppr ty_binds])
         ; return (float_eqs, wanteds { wc_flat = remaining_flats }) }
    where
 -    is_floatable :: Ct -> Bool
 -    is_floatable ct
 -       = case classifyPredType (ctPred ct) of
 -            EqPred ty1 ty2 -> skol_set `disjointVarSet` tyVarsOfType ty1
 -                           && skol_set `disjointVarSet` tyVarsOfType ty2
 -            _ -> False
 -
 -    skol_set = fixVarSet mk_next (mkVarSet skols)
 -    mk_next tvs = foldr grow_one tvs flat_eqs
 -    flat_eqs :: [(TcTyVarSet, TcTyVarSet)]
 -    flat_eqs = [ (tyVarsOfType ty1, tyVarsOfType ty2)
 -               | EqPred ty1 ty2 <- map (classifyPredType . ctPred) (bagToList flats)]
 -    grow_one (tvs1,tvs2) tvs
 -      | intersectsVarSet tvs tvs1 = tvs `unionVarSet` tvs2
 -      | intersectsVarSet tvs tvs2 = tvs `unionVarSet` tvs2
 -      | otherwise                 = tvs
 +    (float_eqs, remaining_flats) = partitionBag float_me flats
 +    float_me :: Ct -> Bool
 +    float_me ct = isEqPred pred && skol_set `disjointVarSet` tyVarsOfType pred
 +       where
 +         pred = ctPred ct
 +    skol_set = mkVarSet skols
  \end{code}
  
+ Note [Do not float equalities if there are insolubles]
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ If we have (t::* ~ s::*->*), we'll get a Derived insoluble equality.
+ If we float the equality outwards, we'll get *another* Derived
+ insoluble equality one level out, so the same error will be reported
+ twice.  However, the equality is insoluble anyway, and when there are
+ any insolubles we report only them, so there is no point in floating.
  Note [When does an implication have given equalities?]
  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
       NB: This note is mainly referred to from TcSMonad
Simple merge
@@@ -1,19 -1,20 +1,21 @@@
- TYPE SIGNATURES\r
-   emptyL :: forall a. ListColl a\r
-   test2 ::\r
-     forall c t t1. (Elem c ~ (t, t1), Coll c, Num t1, Num t) => c -> c\r
- TYPE CONSTRUCTORS\r
-   class Coll c where\r
-     type family Elem c :: * open\r
-     empty :: c\r
-     insert :: Elem c -> c -> c\r
-   data ListColl a = L [a]\r
-     Promotable\r
- COERCION AXIOMS\r
-   axiom Foo.TFCo:R:ElemListColl :: Elem (ListColl a) = a\r
- INSTANCES\r
-   instance Coll (ListColl a) -- Defined at T3017.hs:12:11\r
- FAMILY INSTANCES\r
-   type Elem (ListColl a)\r
- Dependent modules: []\r
- Dependent packages: [base, ghc-prim, integer-gmp]\r
+ TYPE SIGNATURES
+   emptyL :: forall a. ListColl a
+   test2 ::
+     forall c t t1. (Coll c, Num t1, Num t, Elem c ~ (t, t1)) => c -> c
+ TYPE CONSTRUCTORS
+   class Coll c where
+     type family Elem c :: * open
+     empty :: c
+     insert :: Elem c -> c -> c
+   data ListColl a = L [a]
+     Promotable
+ COERCION AXIOMS
+   axiom Foo.TFCo:R:ElemListColl :: Elem (ListColl a) = a
+ INSTANCES
+   instance Coll (ListColl a) -- Defined at T3017.hs:12:11
+ FAMILY INSTANCES
+   type Elem (ListColl a)
+ Dependent modules: []
+ Dependent packages: [base-4.8.0.0, ghc-prim-0.3.1.0,
+                      integer-gmp-0.5.1.0]
++
@@@ -1,15 -1,16 +1,16 @@@
\r
- T7729.hs:28:14:\r
-     Could not deduce (BasePrimMonad m ~ t0 (BasePrimMonad m))\r
-     from the context (PrimMonad (BasePrimMonad (Rand m)),\r
-                       Monad (Rand m),\r
-                       MonadPrim m)\r
-       bound by the instance declaration at T7729.hs:26:10-42\r
-     The type variable ‘t0’ is ambiguous\r
-     Expected type: t0 (BasePrimMonad m) a -> Rand m a\r
-       Actual type: BasePrimMonad (Rand m) a -> Rand m a\r
-     Relevant bindings include\r
-       liftPrim :: BasePrimMonad (Rand m) a -> Rand m a\r
-         (bound at T7729.hs:28:3)\r
-     In the first argument of ‘(.)’, namely ‘liftPrim’\r
-     In the expression: liftPrim . lift\r
 -
+ T7729.hs:36:14:
+     Could not deduce (BasePrimMonad (Rand m)
+                       ~ t0 (BasePrimMonad (Rand m)))
+     from the context (PrimMonad (BasePrimMonad (Rand m)),
+                       Monad (Rand m),
+                       MonadPrim m)
+       bound by the instance declaration at T7729.hs:34:10-42
+     The type variable ‘t0’ is ambiguous
+     Expected type: t0 (BasePrimMonad (Rand m)) a -> Rand m a
+       Actual type: BasePrimMonad (Rand m) a -> Rand m a
+     Relevant bindings include
+       liftPrim :: BasePrimMonad (Rand m) a -> Rand m a
+         (bound at T7729.hs:36:3)
+     In the first argument of ‘(.)’, namely ‘liftPrim’
+     In the expression: liftPrim . lift
++
@@@ -1,15 -1,13 +1,13 @@@
\r
- T8227.hs:16:27:\r
-     Couldn't match type ‘Scalar (V a)’\r
-                   with ‘Scalar (V a) -> Scalar (V a)’\r
-     Expected type: Scalar (V a)\r
-       Actual type: Scalar (V (Scalar (V a)))\r
-                    -> Scalar (V (Scalar (V a)))\r
-     Relevant bindings include\r
-       seg :: a (bound at T8227.hs:16:21)\r
-       eps :: Scalar (V a) (bound at T8227.hs:16:17)\r
-       absoluteToParam :: Scalar (V a) -> a -> Scalar (V a)\r
-         (bound at T8227.hs:16:1)\r
-     In the expression: arcLengthToParam eps eps\r
-     In an equation for ‘absoluteToParam’:\r
-         absoluteToParam eps seg = arcLengthToParam eps eps\r
 -
+ T8227.hs:16:44:
+     Couldn't match type ‘Scalar (V a)’
+                   with ‘Scalar (V a) -> Scalar (V a)’
+     Expected type: Scalar (V (Scalar (V a)))
+       Actual type: Scalar (V a)
+     Relevant bindings include
+       seg :: a (bound at T8227.hs:16:21)
+       eps :: Scalar (V a) (bound at T8227.hs:16:17)
+       absoluteToParam :: Scalar (V a) -> a -> Scalar (V a)
+         (bound at T8227.hs:16:1)
+     In the first argument of ‘arcLengthToParam’, namely ‘eps’
+     In the expression: arcLengthToParam eps eps
++
@@@ -1,35 -1,35 +1,35 @@@
\r
- T8518.hs:14:18:\r
-     Could not deduce (F c ~ Maybe (F c))\r
-     from the context (Continuation c)\r
-       bound by the type signature for\r
-                  callCont :: Continuation c => c -> Z c -> B c -> Maybe (F c)\r
-       at T8518.hs:13:13-64\r
-     Relevant bindings include\r
-       b :: B c (bound at T8518.hs:14:14)\r
-       z :: Z c (bound at T8518.hs:14:12)\r
-       c :: c (bound at T8518.hs:14:10)\r
-       callCont :: c -> Z c -> B c -> Maybe (F c) (bound at T8518.hs:14:1)\r
-     In the expression: rpt (4 :: Int) c z b\r
-     In an equation for ‘callCont’:\r
-         callCont c z b\r
-           = rpt (4 :: Int) c z b\r
-           where\r
-               rpt 0 c' z' b' = fromJust (fst <$> (continue c' z' b'))\r
-               rpt i c' z' b' = let ... in rpt (i - 1) c''\r
\r
- T8518.hs:17:78:\r
-     Could not deduce (F a1 ~ (Z a1 -> B a1 -> F a1))\r
-     from the context (Continuation c)\r
-       bound by the type signature for\r
-                  callCont :: Continuation c => c -> Z c -> B c -> Maybe (F c)\r
-       at T8518.hs:13:13-64\r
-     Relevant bindings include\r
-       c'' :: a1 (bound at T8518.hs:17:30)\r
-       b' :: B a1 (bound at T8518.hs:17:21)\r
-       z' :: Z a1 (bound at T8518.hs:17:18)\r
-       c' :: a1 (bound at T8518.hs:17:15)\r
-       rpt :: a -> a1 -> Z a1 -> B a1 -> F a1 (bound at T8518.hs:16:9)\r
-     In the expression: rpt (i - 1) c''\r
-     In the expression:\r
-       let c'' = fromJust (snd <$> (continue c' z' b')) in rpt (i - 1) c''\r
 -
+ T8518.hs:14:18:
+     Could not deduce (F c ~ Maybe (F c))
+     from the context (Continuation c)
+       bound by the type signature for
+                  callCont :: Continuation c => c -> Z c -> B c -> Maybe (F c)
+       at T8518.hs:13:13-64
+     Relevant bindings include
+       b :: B c (bound at T8518.hs:14:14)
+       z :: Z c (bound at T8518.hs:14:12)
+       c :: c (bound at T8518.hs:14:10)
+       callCont :: c -> Z c -> B c -> Maybe (F c) (bound at T8518.hs:14:1)
+     In the expression: rpt (4 :: Int) c z b
+     In an equation for ‘callCont’:
+         callCont c z b
+           = rpt (4 :: Int) c z b
+           where
+               rpt 0 c' z' b' = fromJust (fst <$> (continue c' z' b'))
+               rpt i c' z' b' = let ... in rpt (i - 1) c''
+ T8518.hs:17:78:
+     Could not deduce (F a1 ~ (Z a1 -> B a1 -> F a1))
+     from the context (Continuation c)
+       bound by the type signature for
+                  callCont :: Continuation c => c -> Z c -> B c -> Maybe (F c)
+       at T8518.hs:13:13-64
+     Relevant bindings include
+       c'' :: a1 (bound at T8518.hs:17:30)
+       b' :: B a1 (bound at T8518.hs:17:21)
+       z' :: Z a1 (bound at T8518.hs:17:18)
+       c' :: a1 (bound at T8518.hs:17:15)
+       rpt :: a -> a1 -> Z a1 -> B a1 -> F a1 (bound at T8518.hs:16:9)
+     In the expression: rpt (i - 1) c''
+     In the expression:
+       let c'' = fromJust (snd <$> (continue c' z' b')) in rpt (i - 1) c''
++