\begin{code}
module TcInteract (
solveInteract, AtomicInert,
- InertSet, emptyInert, updInertSet, extractUnsolved, solveOne,
- listToWorkList
+ InertSet, emptyInert, updInertSet, extractUnsolved, solveOne
) where
#include "HsVersions.h"
-- See Note [InertSet invariants]
data InertSet
- = IS { inert_cts :: Bag.Bag CanonicalCt
+ = IS { inert_eqs :: Bag.Bag CanonicalCt -- Equalities only (CTyEqCan,CFunEqCan)
+ , inert_cts :: Bag.Bag CanonicalCt -- Other constraints
+ , inert_fds :: FDImprovements -- List of pairwise improvements that have kicked in already
+ -- and reside either in the worklist or in the inerts
, inert_fsks :: Map.Map TcTyVar [(TcTyVar,Coercion)] }
-- See Note [InertSet FlattenSkolemEqClass]
+type FDImprovement = (PredType,PredType)
+type FDImprovements = [(PredType,PredType)]
+
instance Outputable InertSet where
- ppr is = vcat [ vcat (map ppr (Bag.bagToList $ inert_cts is))
+ ppr is = vcat [ vcat (map ppr (Bag.bagToList $ inert_eqs is))
+ , vcat (map ppr (Bag.bagToList $ inert_cts is))
, vcat (map (\(v,rest) -> ppr v <+> text "|->" <+> hsep (map (ppr.fst) rest))
(Map.toList $ inert_fsks is)
)
]
emptyInert :: InertSet
-emptyInert = IS { inert_cts = Bag.emptyBag, inert_fsks = Map.empty }
+emptyInert = IS { inert_eqs = Bag.emptyBag
+ , inert_cts = Bag.emptyBag, inert_fsks = Map.empty, inert_fds = [] }
updInertSet :: InertSet -> AtomicInert -> InertSet
-- Introduces an element in the inert set for the first time
-updInertSet (IS { inert_cts = cts, inert_fsks = fsks })
+updInertSet (IS { inert_eqs = eqs, inert_cts = cts, inert_fsks = fsks, inert_fds = fdis })
item@(CTyEqCan { cc_id = cv
, cc_tyvar = tv1
, cc_rhs = xi })
| Just tv2 <- tcGetTyVar_maybe xi,
FlatSkol {} <- tcTyVarDetails tv1,
FlatSkol {} <- tcTyVarDetails tv2
- = let cts' = cts `Bag.snocBag` item
+ = let eqs' = eqs `Bag.snocBag` item
fsks' = Map.insertWith (++) tv2 [(tv1, mkCoVarCoercion cv)] fsks
-- See Note [InertSet FlattenSkolemEqClass]
- in IS { inert_cts = cts', inert_fsks = fsks' }
-updInertSet (IS { inert_cts = cts
- , inert_fsks = fsks }) item
+ in IS { inert_eqs = eqs', inert_cts = cts, inert_fsks = fsks', inert_fds = fdis }
+updInertSet (IS { inert_eqs = eqs, inert_cts = cts
+ , inert_fsks = fsks, inert_fds = fdis }) item
+ | isEqCCan item
+ = let eqs' = eqs `Bag.snocBag` item
+ in IS { inert_eqs = eqs', inert_cts = cts, inert_fsks = fsks, inert_fds = fdis }
+ | otherwise
= let cts' = cts `Bag.snocBag` item
- in IS { inert_cts = cts', inert_fsks = fsks }
+ in IS { inert_eqs = eqs, inert_cts = cts', inert_fsks = fsks, inert_fds = fdis }
+
+updInertSetFDImprs :: InertSet -> Maybe FDImprovement -> InertSet
+updInertSetFDImprs is (Just fdi) = is { inert_fds = fdi : inert_fds is }
+updInertSetFDImprs is Nothing = is
foldlInertSetM :: (Monad m) => (a -> AtomicInert -> m a) -> a -> InertSet -> m a
-foldlInertSetM k z (IS { inert_cts = cts })
- = Bag.foldlBagM k z cts
+-- Prioritize over the equalities see Note [Prioritizing Equalities]
+foldlInertSetM k z (IS { inert_eqs = eqs, inert_cts = cts })
+ = do { z' <- Bag.foldlBagM k z eqs
+ ; Bag.foldlBagM k z' cts }
extractUnsolved :: InertSet -> (InertSet, CanonicalCts)
-extractUnsolved is@(IS {inert_cts = cts})
- = (is { inert_cts = cts'}, unsolved)
- where (unsolved, cts') = Bag.partitionBag isWantedCt cts
+extractUnsolved is@(IS {inert_eqs = eqs, inert_cts = cts, inert_fds = fdis })
+ = let is_init = is { inert_eqs = emptyCCan
+ , inert_cts = solved_cts, inert_fsks = Map.empty, inert_fds = fdis }
+ is_final = Bag.foldlBag updInertSet is_init solved_eqs -- Add equalities carefully
+ in (is_final, unsolved)
+ where (unsolved_cts, solved_cts) = Bag.partitionBag isWantedCt cts
+ (unsolved_eqs, solved_eqs) = Bag.partitionBag isWantedCt eqs
+ unsolved = unsolved_cts `unionBags` unsolved_eqs
getFskEqClass :: InertSet -> TcTyVar -> [(TcTyVar,Coercion)]
lkp Nothing ct@(CTyEqCan {cc_tyvar = tv'}) | tv' == tv = Just ct
lkp other _ct = other
+haveBeenImproved :: FDImprovements -> PredType -> PredType -> Bool
+haveBeenImproved [] _ _ = False
+haveBeenImproved ((pty1,pty2):fdimprs) pty1' pty2'
+ | tcEqPred pty1 pty1' && tcEqPred pty2 pty2'
+ = True
+ | tcEqPred pty1 pty2' && tcEqPred pty2 pty1'
+ = True
+ | otherwise
+ = haveBeenImproved fdimprs pty1' pty2'
+
+getFDImprovements :: InertSet -> FDImprovements
+-- Return a list of the improvements that have kicked in so far
+getFDImprovements = inert_fds
+
isWantedCt :: CanonicalCt -> Bool
isWantedCt ct = isWanted (cc_flavor ct)
type AtomicInert = CanonicalCt -- constraint pulled from InertSet
type WorkItem = CanonicalCt -- constraint pulled from WorkList
-type WorkList = CanonicalCts -- A mixture of Given, Wanted, and Solved
-type SWorkList = WorkList -- A worklist of solved
-
-
-listToWorkList :: [WorkItem] -> WorkList
-listToWorkList = Bag.listToBag
+-- A mixture of Given, Wanted, and Derived constraints.
+-- We split between equalities and the rest to process equalities first.
+data WorkList = WL { wl_eqs :: CanonicalCts -- Equalities (CTyEqCan, CFunEqCan)
+ , wl_other :: CanonicalCts -- Other
+ }
+type SWorkList = WorkList -- A worklist of solved
unionWorkLists :: WorkList -> WorkList -> WorkList
-unionWorkLists = Bag.unionBags
+unionWorkLists wl1 wl2
+ = WL { wl_eqs = andCCan (wl_eqs wl1) (wl_eqs wl2)
+ , wl_other = andCCan (wl_other wl1) (wl_other wl2) }
foldlWorkListM :: (Monad m) => (a -> WorkItem -> m a) -> a -> WorkList -> m a
-foldlWorkListM = Bag.foldlBagM
+-- This fold prioritizes equalities
+foldlWorkListM f r wl
+ = do { r' <- Bag.foldlBagM f r (wl_eqs wl)
+ ; Bag.foldlBagM f r' (wl_other wl) }
isEmptyWorkList :: WorkList -> Bool
-isEmptyWorkList = Bag.isEmptyBag
+isEmptyWorkList wl = isEmptyCCan (wl_eqs wl) && isEmptyCCan (wl_other wl)
emptyWorkList :: WorkList
-emptyWorkList = Bag.emptyBag
+emptyWorkList = WL { wl_eqs = emptyCCan, wl_other = emptyCCan }
+
+mkEqWorkList :: CanonicalCts -> WorkList
+-- Precondition: *ALL* equalities
+mkEqWorkList eqs = WL { wl_eqs = eqs, wl_other = emptyCCan }
+
+mkNonEqWorkList :: CanonicalCts -> WorkList
+-- Precondition: *NO* equalities
+mkNonEqWorkList cts = WL { wl_eqs = emptyCCan, wl_other = cts }
+
+workListFromCCans :: CanonicalCts -> WorkList
+-- Generic, no precondition
+workListFromCCans cts = WL eqs others
+ where (eqs, others) = Bag.partitionBag isEqCCan cts
+
+-- Convenience
+singleEqWL :: CanonicalCt -> WorkList
+singleNonEqWL :: CanonicalCt -> WorkList
+singleEqWL = mkEqWorkList . singleCCan
+singleNonEqWL = mkNonEqWorkList . singleCCan
-singletonWorkList :: CanonicalCt -> WorkList
-singletonWorkList ct = singleCCan ct
data StopOrContinue
= Stop -- Work item is consumed
, ptext (sLit "new work =") <+> ppr work <> comma
, ptext (sLit "stop =") <+> ppr stop])
+instance Outputable WorkList where
+ ppr (WL eqcts othercts) = vcat [ppr eqcts, ppr othercts]
+
type SimplifierStage = WorkItem -> InertSet -> TcS StageResult
-- Combine a sequence of simplifier 'stages' to create a pipeline
, sr_stop = ContinueWith work_item })
= do { itr <- stage work_item inerts
; traceTcS ("Stage result (" ++ name ++ ")") (ppr itr)
- ; let itr' = itr { sr_new_work = sr_new_work itr
- `unionWorkLists` accum_work }
+ ; let itr' = itr { sr_new_work = accum_work `unionWorkLists` sr_new_work itr }
; run_pipeline stages itr' }
\end{code}
-- returning an extended inert set.
--
-- See Note [Touchables and givens].
-solveInteract :: InertSet -> WorkList -> TcS InertSet
+solveInteract :: InertSet -> CanonicalCts -> TcS InertSet
solveInteract inert ws
= do { dyn_flags <- getDynFlags
- ; solveInteractWithDepth (ctxtStkDepth dyn_flags,0,[]) inert ws
+ ; let worklist = workListFromCCans ws
+ ; solveInteractWithDepth (ctxtStkDepth dyn_flags,0,[]) inert worklist
}
solveOne :: InertSet -> WorkItem -> TcS InertSet
solveOne inerts workItem
\begin{code}
spontaneousSolveStage :: SimplifierStage
spontaneousSolveStage workItem inerts
- = do { mSolve <- trySpontaneousSolve workItem inerts
+ = do { mSolve <- trySpontaneousSolve workItem inerts
; case mSolve of
Nothing -> -- no spontaneous solution for him, keep going
- return $ SR { sr_new_work = emptyWorkList
- , sr_inerts = inerts
+ return $ SR { sr_new_work = emptyWorkList
+ , sr_inerts = inerts
, sr_stop = ContinueWith workItem }
- Just workList' -> -- He has been solved; workList' are all givens
+ Just workList' -> -- He has been solved; workList' are all givens
return $ SR { sr_new_work = workList'
, sr_inerts = inerts
- , sr_stop = Stop }
+ , sr_stop = Stop }
}
{-- This is all old code, but does not quite work now. The problem is that due to
-- * Nothing if we were not able to solve it
-- * Just wi' if we solved it, wi' (now a "given") should be put in the work list.
-- See Note [Touchables and givens]
--- Note, just passing the inerts through for the skolem equivalence classes
+-- NB: just passing the inerts through for the skolem equivalence classes
trySpontaneousSolve :: WorkItem -> InertSet -> TcS (Maybe SWorkList)
trySpontaneousSolve (CTyEqCan { cc_id = cv, cc_flavor = gw, cc_tyvar = tv1, cc_rhs = xi }) inerts
| isGiven gw
; case (tch1, tch2) of
(True, True) -> trySpontaneousEqTwoWay inerts cv gw tv1 tv2
(True, False) -> trySpontaneousEqOneWay inerts cv gw tv1 xi
- (False, True) | tyVarKind tv1 `isSubKind` tyVarKind tv2
- -> trySpontaneousEqOneWay inerts cv gw tv2 (mkTyVarTy tv1)
+ (False, True) -> trySpontaneousEqOneWay inerts cv gw tv2 (mkTyVarTy tv1)
_ -> return Nothing }
| otherwise
= do { tch1 <- isTouchableMetaTyVar tv1
trySpontaneousEqOneWay :: InertSet -> CoVar -> CtFlavor -> TcTyVar -> Xi
-> TcS (Maybe SWorkList)
-- tv is a MetaTyVar, not untouchable
--- Precondition: kind(xi) is a sub-kind of kind(tv)
trySpontaneousEqOneWay inerts cv gw tv xi
- | not (isSigTyVar tv) || isTyVarTy xi
+ | not (isSigTyVar tv) || isTyVarTy xi,
+ typeKind xi `isSubKind` tyVarKind tv
= solveWithIdentity inerts cv gw tv xi
| otherwise
= return Nothing
-- Both tyvars are *touchable* MetaTyvars
-- By the CTyEqCan invariant, k2 `isSubKind` k1
trySpontaneousEqTwoWay inerts cv gw tv1 tv2
- | k1 `eqKind` k2
+ | k1 `isSubKind` k2
, nicer_to_update_tv2 = solveWithIdentity inerts cv gw tv2 (mkTyVarTy tv1)
- | otherwise = ASSERT( k2 `isSubKind` k1 )
- solveWithIdentity inerts cv gw tv1 (mkTyVarTy tv2)
+ | k2 `isSubKind` k1
+ = solveWithIdentity inerts cv gw tv1 (mkTyVarTy tv2)
+ | otherwise = return Nothing
where
k1 = tyVarKind tv1
k2 = tyVarKind tv2
nicer_to_update_tv2 = isSigTyVar tv1 || isSystemName (Var.varName tv2)
\end{code}
+
+Note [Spontaneous solving and kind compatibility]
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+Note that our canonical constraints insist that only *given* equalities (tv ~ xi)
+or (F xis ~ rhs) require the LHS and the RHS to have exactly the same kinds.
+
+ - We have to require this because:
+ Given equalities can be freely used to rewrite inside
+ other types or constraints.
+ - We do not have to do the same for wanteds because:
+ First, wanted equations (tv ~ xi) where tv is a touchable unification variable
+ may have kinds that do not agree (the kind of xi must be a sub kind of the kind of tv).
+ Second, any potential kind mismatch will result in the constraint not being soluble,
+ which will be reported anyway. This is the reason that @trySpontaneousOneWay@ and
+ @trySpontaneousTwoWay@ will perform a kind compatibility check, and only then will
+ they proceed to @solveWithIdentity@.
+
+Caveat:
+ - Givens from higher-rank, such as:
+ type family T b :: * -> * -> *
+ type instance T Bool = (->)
+
+ f :: forall a. ((T a ~ (->)) => ...) -> a -> ...
+ flop = f (...) True
+ Whereas we would be able to apply the type instance, we would not be able to
+ use the given (T Bool ~ (->)) in the body of 'flop'
+
Note [Loopy spontaneous solving]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Consider the original wanted:
Derived {} -> setDerivedCoBind cv co
_ -> pprPanic "Can't spontaneously solve *given*" empty
-- See Note [Avoid double unifications]
- ; return (Just cts) }
+ ; return $ Just (mkEqWorkList cts) }
occurCheck :: VarEnv (TcTyVar, TcType) -> InertSet
-> TcTyVar -> TcType -> Maybe (TcType,CoercionI)
, ir_new_work :: WorkList
-- new work items to add to the WorkList
+
+ , ir_improvement :: Maybe FDImprovement -- In case improvement kicked in
}
-- What to do with the inert reactant.
deriving Eq
mkIRContinue :: Monad m => WorkItem -> InertAction -> WorkList -> m InteractResult
-mkIRContinue wi keep newWork = return $ IR (ContinueWith wi) keep newWork
+mkIRContinue wi keep newWork = return $ IR (ContinueWith wi) keep newWork Nothing
mkIRStop :: Monad m => InertAction -> WorkList -> m InteractResult
-mkIRStop keep newWork = return $ IR Stop keep newWork
+mkIRStop keep newWork = return $ IR Stop keep newWork Nothing
+
+mkIRStop_RecordImprovement :: Monad m => InertAction -> WorkList -> FDImprovement -> m InteractResult
+mkIRStop_RecordImprovement keep newWork fdimpr = return $ IR Stop keep newWork (Just fdimpr)
+
dischargeWorkItem :: Monad m => m InteractResult
-dischargeWorkItem = mkIRStop KeepInert emptyCCan
+dischargeWorkItem = mkIRStop KeepInert emptyWorkList
noInteraction :: Monad m => WorkItem -> m InteractResult
-noInteraction workItem = mkIRContinue workItem KeepInert emptyCCan
+noInteraction workItem = mkIRContinue workItem KeepInert emptyWorkList
data WhichComesFromInert = LeftComesFromInert | RightComesFromInert
interactWithInertsStage workItem inert
= foldlInertSetM interactNext initITR inert
where
- initITR = SR { sr_inerts = emptyInert
- , sr_new_work = emptyCCan
+ initITR = SR { sr_inerts = emptyInert { inert_fds = inert_fds inert } -- Pick up the improvements!
+ , sr_new_work = emptyWorkList
, sr_stop = ContinueWith workItem }
interactNext :: StageResult -> AtomicInert -> TcS StageResult
interactNext it inert
| ContinueWith workItem <- sr_stop it
- = do { ir <- interactWithInert inert workItem
- ; let inerts = sr_inerts it
- ; return $ SR { sr_inerts = if ir_inert_action ir == KeepInert
- then inerts `updInertSet` inert
- else inerts
+ = do { let inerts = sr_inerts it
+ fdimprs_old = getFDImprovements inerts
+
+ ; ir <- interactWithInert fdimprs_old inert workItem
+
+ -- New inerts depend on whether we KeepInert or not and must
+ -- be updated with FD improvement information from the interaction result (ir)
+ ; let inerts_new = updInertSetFDImprs upd_inert (ir_improvement ir)
+ upd_inert = if ir_inert_action ir == KeepInert
+ then inerts `updInertSet` inert else inerts
+
+ ; return $ SR { sr_inerts = inerts_new
, sr_new_work = sr_new_work it `unionWorkLists` ir_new_work ir
, sr_stop = ir_stop ir } }
| otherwise = return $ itrAddInert inert it
itrAddInert inert itr = itr { sr_inerts = (sr_inerts itr) `updInertSet` inert }
-- Do a single interaction of two constraints.
-interactWithInert :: AtomicInert -> WorkItem -> TcS InteractResult
-interactWithInert inert workitem
+interactWithInert :: FDImprovements -> AtomicInert -> WorkItem -> TcS InteractResult
+interactWithInert fdimprs inert workitem
= do { ctxt <- getTcSContext
; let is_allowed = allowedInteraction (simplEqsOnly ctxt) inert workitem
inert_ev = cc_id inert
_ -> return True
; if is_allowed && rec_ev_ok then
- doInteractWithInert inert workitem
+ doInteractWithInert fdimprs inert workitem
else
noInteraction workitem
}
allowedInteraction _ _ _ = True
--------------------------------------------
-doInteractWithInert :: CanonicalCt -> CanonicalCt -> TcS InteractResult
+doInteractWithInert :: FDImprovements -> CanonicalCt -> CanonicalCt -> TcS InteractResult
-- Identical class constraints.
-doInteractWithInert
+doInteractWithInert fdimprs
(CDictCan { cc_id = d1, cc_flavor = fl1, cc_class = cls1, cc_tyargs = tys1 })
workItem@(CDictCan { cc_id = d2, cc_flavor = fl2, cc_class = cls2, cc_tyargs = tys2 })
| cls1 == cls2 && (and $ zipWith tcEqType tys1 tys2)
| cls1 == cls2 && (not (isGiven fl1 && isGiven fl2))
= -- See Note [When improvement happens]
- do { let work_item_pred_loc = (ClassP cls2 tys2, ppr d2)
- inert_pred_loc = (ClassP cls1 tys1, ppr d1)
+ do { let pty1 = ClassP cls1 tys1
+ pty2 = ClassP cls2 tys2
+ work_item_pred_loc = (pty2, ppr d2)
+ inert_pred_loc = (pty1, ppr d1)
loc = combineCtLoc fl1 fl2
eqn_pred_locs = improveFromAnother work_item_pred_loc inert_pred_loc
+
; wevvars <- mkWantedFunDepEqns loc eqn_pred_locs
+ ; fd_cts <- canWanteds wevvars
+ ; let fd_work = mkEqWorkList fd_cts
-- See Note [Generating extra equalities]
- ; workList <- canWanteds wevvars
- ; mkIRContinue workItem KeepInert workList -- Keep the inert there so we avoid
- -- re-introducing the fundep equalities
+ ; traceTcS "Checking if improvements existed." (ppr fdimprs)
+-- ; if isEmptyCCan fd_cts || not (isWanted fl2) || haveBeenImproved fdimprs pty1 pty2 then
+ ; if isEmptyCCan fd_cts || haveBeenImproved fdimprs pty1 pty2 then
+ -- Must keep going
+ mkIRContinue workItem KeepInert fd_work
+ else do { traceTcS "Recording improvement and throwing item back in worklist." (ppr (pty1,pty2))
+ ; mkIRStop_RecordImprovement KeepInert
+ (fd_work `unionWorkLists` singleNonEqWL workItem) (pty1,pty2)
+ }
-- See Note [FunDep Reactions]
}
-- Class constraint and given equality: use the equality to rewrite
-- the class constraint.
-doInteractWithInert (CTyEqCan { cc_id = cv, cc_flavor = ifl, cc_tyvar = tv, cc_rhs = xi })
+doInteractWithInert _fdimprs
+ (CTyEqCan { cc_id = cv, cc_flavor = ifl, cc_tyvar = tv, cc_rhs = xi })
(CDictCan { cc_id = dv, cc_flavor = wfl, cc_class = cl, cc_tyargs = xis })
| ifl `canRewrite` wfl
, tv `elemVarSet` tyVarsOfTypes xis
-- Int (w). But now we must go back through the rest of the inert
-- set again, to find that it can now be discharged by the given D
-- Int instance.
+
+ -- DV: Update to the comment above:
+ -- This situation can no longer happen, see Note [Prioritizing equalities]
+ -- so we are good to simply keep going with the rewritten dictionary to rewrite
+ -- it as much as possible before reaching any other dictionary constraints!
= do { rewritten_dict <- rewriteDict (cv,tv,xi) (dv,wfl,cl,xis)
- ; mkIRStop KeepInert (singleCCan rewritten_dict) }
+ ; mkIRContinue rewritten_dict KeepInert emptyWorkList }
+-- ; mkIRStop KeepInert $ singleNonEqWL rewritten_dict }
-doInteractWithInert (CDictCan { cc_id = dv, cc_flavor = ifl, cc_class = cl, cc_tyargs = xis })
+doInteractWithInert _fdimprs
+ (CDictCan { cc_id = dv, cc_flavor = ifl, cc_class = cl, cc_tyargs = xis })
workItem@(CTyEqCan { cc_id = cv, cc_flavor = wfl, cc_tyvar = tv, cc_rhs = xi })
| wfl `canRewrite` ifl
, tv `elemVarSet` tyVarsOfTypes xis
= do { rewritten_dict <- rewriteDict (cv,tv,xi) (dv,ifl,cl,xis)
- ; mkIRContinue workItem DropInert (singleCCan rewritten_dict) }
+ ; mkIRContinue workItem DropInert (singleNonEqWL rewritten_dict) }
-- Class constraint and given equality: use the equality to rewrite
-- the class constraint.
-doInteractWithInert (CTyEqCan { cc_id = cv, cc_flavor = ifl, cc_tyvar = tv, cc_rhs = xi })
+doInteractWithInert _fdimprs
+ (CTyEqCan { cc_id = cv, cc_flavor = ifl, cc_tyvar = tv, cc_rhs = xi })
(CIPCan { cc_id = ipid, cc_flavor = wfl, cc_ip_nm = nm, cc_ip_ty = ty })
| ifl `canRewrite` wfl
, tv `elemVarSet` tyVarsOfType ty
= do { rewritten_ip <- rewriteIP (cv,tv,xi) (ipid,wfl,nm,ty)
- ; mkIRStop KeepInert (singleCCan rewritten_ip) }
+ ; mkIRContinue rewritten_ip KeepInert emptyWorkList }
+-- ; mkIRStop KeepInert (singleNonEqWL rewritten_ip) }
-doInteractWithInert (CIPCan { cc_id = ipid, cc_flavor = ifl, cc_ip_nm = nm, cc_ip_ty = ty })
+doInteractWithInert _fdimprs
+ (CIPCan { cc_id = ipid, cc_flavor = ifl, cc_ip_nm = nm, cc_ip_ty = ty })
workItem@(CTyEqCan { cc_id = cv, cc_flavor = wfl, cc_tyvar = tv, cc_rhs = xi })
| wfl `canRewrite` ifl
, tv `elemVarSet` tyVarsOfType ty
= do { rewritten_ip <- rewriteIP (cv,tv,xi) (ipid,ifl,nm,ty)
- ; mkIRContinue workItem DropInert (singleCCan rewritten_ip) }
+ ; mkIRContinue workItem DropInert (singleNonEqWL rewritten_ip) }
-- Two implicit parameter constraints. If the names are the same,
-- but their types are not, we generate a wanted type equality
-- that equates the type (this is "improvement").
-- However, we don't actually need the coercion evidence,
-- so we just generate a fresh coercion variable that isn't used anywhere.
-doInteractWithInert (CIPCan { cc_id = id1, cc_flavor = ifl, cc_ip_nm = nm1, cc_ip_ty = ty1 })
+doInteractWithInert _fdimprs
+ (CIPCan { cc_id = id1, cc_flavor = ifl, cc_ip_nm = nm1, cc_ip_ty = ty1 })
workItem@(CIPCan { cc_flavor = wfl, cc_ip_nm = nm2, cc_ip_ty = ty2 })
| nm1 == nm2 && isGiven wfl && isGiven ifl
= -- See Note [Overriding implicit parameters]
-- Dump the inert item, override totally with the new one
-- Do not require type equality
- mkIRContinue workItem DropInert emptyCCan
+ mkIRContinue workItem DropInert emptyWorkList
| nm1 == nm2 && ty1 `tcEqType` ty2
= solveOneFromTheOther (id1,ifl) workItem
= -- See Note [When improvement happens]
do { co_var <- newWantedCoVar ty1 ty2
; let flav = Wanted (combineCtLoc ifl wfl)
- ; mkCanonical flav co_var >>= mkIRContinue workItem KeepInert }
+ ; cans <- mkCanonical flav co_var
+ ; mkIRContinue workItem KeepInert (mkEqWorkList cans) }
-- Inert: equality, work item: function equality
-- we will ``expose'' x2 and x4 to rewriting.
-- Otherwise, we can try rewriting the type function equality with the equality.
-doInteractWithInert (CTyEqCan { cc_id = cv1, cc_flavor = ifl, cc_tyvar = tv, cc_rhs = xi1 })
+doInteractWithInert _fdimprs
+ (CTyEqCan { cc_id = cv1, cc_flavor = ifl, cc_tyvar = tv, cc_rhs = xi1 })
(CFunEqCan { cc_id = cv2, cc_flavor = wfl, cc_fun = tc
, cc_tyargs = args, cc_rhs = xi2 })
| ifl `canRewrite` wfl
, tv `elemVarSet` tyVarsOfTypes args
= do { rewritten_funeq <- rewriteFunEq (cv1,tv,xi1) (cv2,wfl,tc,args,xi2)
- ; mkIRStop KeepInert (singleCCan rewritten_funeq) }
+ ; mkIRStop KeepInert (singleEqWL rewritten_funeq) } -- DV: must stop here, because we may no longer be inert after the rewritting.
-- Inert: function equality, work item: equality
-doInteractWithInert (CFunEqCan {cc_id = cv1, cc_flavor = ifl, cc_fun = tc
+doInteractWithInert _fdimprs
+ (CFunEqCan {cc_id = cv1, cc_flavor = ifl, cc_fun = tc
, cc_tyargs = args, cc_rhs = xi1 })
workItem@(CTyEqCan { cc_id = cv2, cc_flavor = wfl, cc_tyvar = tv, cc_rhs = xi2 })
| wfl `canRewrite` ifl
, tv `elemVarSet` tyVarsOfTypes args
= do { rewritten_funeq <- rewriteFunEq (cv2,tv,xi2) (cv1,ifl,tc,args,xi1)
- ; mkIRContinue workItem DropInert (singleCCan rewritten_funeq) }
+ ; mkIRContinue workItem DropInert (singleEqWL rewritten_funeq) }
-doInteractWithInert (CFunEqCan { cc_id = cv1, cc_flavor = fl1, cc_fun = tc1
+doInteractWithInert _fdimprs
+ (CFunEqCan { cc_id = cv1, cc_flavor = fl1, cc_fun = tc1
, cc_tyargs = args1, cc_rhs = xi1 })
workItem@(CFunEqCan { cc_id = cv2, cc_flavor = fl2, cc_fun = tc2
, cc_tyargs = args2, cc_rhs = xi2 })
- | fl1 `canRewrite` fl2 && lhss_match
+ | fl1 `canSolve` fl2 && lhss_match
= do { cans <- rewriteEqLHS LeftComesFromInert (mkCoVarCoercion cv1,xi1) (cv2,fl2,xi2)
- ; mkIRStop KeepInert cans }
- | fl2 `canRewrite` fl1 && lhss_match
+ ; mkIRStop KeepInert (mkEqWorkList cans) }
+ | fl2 `canSolve` fl1 && lhss_match
= do { cans <- rewriteEqLHS RightComesFromInert (mkCoVarCoercion cv2,xi2) (cv1,fl1,xi1)
- ; mkIRContinue workItem DropInert cans }
+ ; mkIRContinue workItem DropInert (mkEqWorkList cans) }
where
lhss_match = tc1 == tc2 && and (zipWith tcEqType args1 args2)
-doInteractWithInert
+doInteractWithInert _fdimprs
inert@(CTyEqCan { cc_id = cv1, cc_flavor = fl1, cc_tyvar = tv1, cc_rhs = xi1 })
workItem@(CTyEqCan { cc_id = cv2, cc_flavor = fl2, cc_tyvar = tv2, cc_rhs = xi2 })
-- Check for matching LHS
- | fl1 `canRewrite` fl2 && tv1 == tv2
+ | fl1 `canSolve` fl2 && tv1 == tv2
= do { cans <- rewriteEqLHS LeftComesFromInert (mkCoVarCoercion cv1,xi1) (cv2,fl2,xi2)
- ; mkIRStop KeepInert cans }
+ ; mkIRStop KeepInert (mkEqWorkList cans) }
- | fl2 `canRewrite` fl1 && tv1 == tv2
+ | fl2 `canSolve` fl1 && tv1 == tv2
= do { cans <- rewriteEqLHS RightComesFromInert (mkCoVarCoercion cv2,xi2) (cv1,fl1,xi1)
- ; mkIRContinue workItem DropInert cans }
+ ; mkIRContinue workItem DropInert (mkEqWorkList cans) }
-- Check for rewriting RHS
| fl1 `canRewrite` fl2 && tv1 `elemVarSet` tyVarsOfType xi2
= do { rewritten_eq <- rewriteEqRHS (cv1,tv1,xi1) (cv2,fl2,tv2,xi2)
- ; mkIRStop KeepInert rewritten_eq }
+ ; mkIRStop KeepInert (mkEqWorkList rewritten_eq) }
| fl2 `canRewrite` fl1 && tv2 `elemVarSet` tyVarsOfType xi1
= do { rewritten_eq <- rewriteEqRHS (cv2,tv2,xi2) (cv1,fl1,tv1,xi1)
- ; mkIRContinue workItem DropInert rewritten_eq }
+ ; mkIRContinue workItem DropInert (mkEqWorkList rewritten_eq) }
-- Finally, if workitem is a Flatten Equivalence Class constraint and the
-- inert is a wanted constraint, even when the workitem cannot rewrite the
isMetaTyVar tv1, -- and has a unification variable lhs
FlatSkol {} <- tcTyVarDetails tv2, -- And workitem is a flatten skolem equality
Just tv2' <- tcGetTyVar_maybe xi2, FlatSkol {} <- tcTyVarDetails tv2'
- = mkIRContinue workItem DropInert (singletonWorkList inert)
+ = mkIRContinue workItem DropInert (singleEqWL inert)
-- Fall-through case for all other situations
-doInteractWithInert _ workItem = noInteraction workItem
+doInteractWithInert _fdimprs _ workItem = noInteraction workItem
-------------------------
-- Equational Rewriting
; return (singleCCan $ CTyEqCan { cc_id = cv2'
, cc_flavor = gw
, cc_tyvar = tv2
- , cc_rhs = xi2'' })
+ , cc_rhs = xi2'' })
}
where
xi2' = substTyWith [tv1] [xi1] xi2
-- Used to ineratct two equalities of the following form:
-- First Equality: co1: (XXX ~ xi1)
-- Second Equality: cv2: (XXX ~ xi2)
--- Where the cv1 `canRewrite` cv2 equality
+-- Where the cv1 `canSolve` cv2 equality
-- We have an option of creating new work (xi1 ~ xi2) OR (xi2 ~ xi1). This
-- depends on whether the left or the right equality comes from the inert set.
-- We must:
(False,RightComesFromInert) ->
newGivOrDerCoVar xi1 xi2 $
mkSymCoercion co1 `mkTransCoercion` mkCoVarCoercion cv2
- ; mkCanonical gw cv2' }
-
-
-
+ ; mkCanonical gw cv2'
+ }
+
solveOneFromTheOther :: (EvVar, CtFlavor) -> CanonicalCt -> TcS InteractResult
-- First argument inert, second argument workitem. They both represent
-- wanted/given/derived evidence for the *same* predicate so we try here to
| isDerived ifl && isDerived wfl
= noInteraction workItem
- | ifl `canRewrite` wfl
+ | ifl `canSolve` wfl
= do { unless (isGiven wfl) $ setEvBind wid (EvId iid)
-- Overwrite the binding, if one exists
-- For Givens, which are lambda-bound, nothing to overwrite,
; dischargeWorkItem }
- | otherwise -- wfl `canRewrite` ifl
+ | otherwise -- wfl `canSolve` ifl
= do { unless (isGiven ifl) $ setEvBind iid (EvId wid)
- ; mkIRContinue workItem DropInert emptyCCan }
+ ; mkIRContinue workItem DropInert emptyWorkList }
where
wfl = cc_flavor workItem
-- Solved in one step and no new wanted work produced.
-- i.e we directly matched a top-level instance
-- No point in caching this in 'inert', nor in adding superclasses
- then return $ SomeTopInt { tir_new_work = emptyCCan
+ then return $ SomeTopInt { tir_new_work = emptyWorkList
, tir_new_inert = Stop }
-- Solved and new wanted work produced, you may cache the
-- (tentatively solved) dictionary as Derived and its superclasses
else do { let solved = makeSolved workItem
; sc_work <- newSCWorkFromFlavored dv (Derived loc) cls xis
+ ; let inst_work = workListFromCCans workList
; return $ SomeTopInt
- { tir_new_work = workList `unionWorkLists` sc_work
+ { tir_new_work = inst_work `unionWorkLists` sc_work
, tir_new_inert = ContinueWith solved } }
}
}
; wevvars <- mkWantedFunDepEqns loc eqn_pred_locs
-- NB: fundeps generate some wanted equalities, but
-- we don't use their evidence for anything
- ; fd_work <- canWanteds wevvars
- ; sc_work <- newSCWorkFromFlavored dv (Derived loc) cls xis
- ; return $ SomeTopInt { tir_new_work = fd_work `unionWorkLists` sc_work
- , tir_new_inert = ContinueWith workItem }
+ ; fd_cts <- canWanteds wevvars
+ ; let fd_work = mkEqWorkList fd_cts
+
+ ; if isEmptyCCan fd_cts then
+ do { sc_work <- newSCWorkFromFlavored dv (Derived loc) cls xis
+ ; return $ SomeTopInt { tir_new_work = fd_work `unionWorkLists` sc_work
+ , tir_new_inert = ContinueWith workItem }
+ }
+ else -- More fundep work produced, don't do any superlcass stuff, just
+ -- thow him back in the worklist prioritizing the solution of fd equalities
+ return $
+ SomeTopInt { tir_new_work = fd_work `unionWorkLists` singleNonEqWL workItem
+ , tir_new_inert = Stop }
+
-- NB: workItem is inert, but it isn't solved
-- keep it as inert, although it's not solved because we
-- have now reacted all its top-level fundep-induced equalities!
-- See Note [FunDep Reactions]
}
--- Otherwise, we have a given or derived
+-- DV: Derived, we will not add any further derived superclasses
+-- [no deep recursive dictionaries!]
+doTopReact (CDictCan { cc_flavor = fl })
+ | isDerived fl
+ = return NoTopInt
+
doTopReact workItem@(CDictCan { cc_id = dv, cc_flavor = fl
, cc_class = cls, cc_tyargs = xis })
= do { sc_work <- newSCWorkFromFlavored dv fl cls xis
_ -> newGivOrDerCoVar xi rhs_ty $
mkSymCoercion (mkCoVarCoercion cv) `mkTransCoercion` coe
- ; workList <- mkCanonical fl cv'
+ ; can_cts <- mkCanonical fl cv'
+ ; let workList = mkEqWorkList can_cts
; return $ SomeTopInt workList Stop }
_
-> panicTcS $ text "TcSMonad.matchFam returned multiple instances!"
d2 := d1 |> D Int cv
But in general it's a bit painful to figure out the necessary coercion,
-so we just take the first approach.
+so we just take the first approach. Here is a better example. Consider:
+ class C a b c | a -> b
+And:
+ [Given] d1 : C T Int Char
+ [Wanted] d2 : C T beta Int
+In this case, it's *not even possible* to solve the wanted immediately.
+So we should simply output the functional dependency and add this guy
+[but NOT its superclasses] back in the worklist. Even worse:
+ [Given] d1 : C T Int beta
+ [Wanted] d2: C T beta Int
+Then it is solvable, but its very hard to detect this on the spot.
It's exactly the same with implicit parameters, except that the
"aggressive" approach would be much easier to implement.
-- Add *all* its superclasses (equalities or not) as new given work
-- See Note [New Wanted Superclass Work]
; sc_vars <- zipWithM inst_one sc_theta1 [0..]
- ; mkCanonicals flavor sc_vars }
+ ; can_cts <- mkCanonicals flavor sc_vars
+ ; return $ workListFromCCans can_cts
+ }
where
inst_one pred n = newGivOrDerEvVar pred (EvSuperClass ev n)
projects / ghc-hetmet.git / blobdiff