+
+
+\begin{code}
+improve inst_env preds
+ = [ eqn | group <- equivClassesByUniq (predTyUnique . fst) preds,
+ eqn <- checkGroup inst_env group ]
+
+----------
+checkGroup :: (Class -> [Instance])
+ -> [(PredType,SDoc)]
+ -> [(Equation, SDoc)]
+ -- The preds are all for the same class or implicit param
+
+checkGroup inst_env (p1@(IParam _ ty, _) : ips)
+ = -- For implicit parameters, all the types must match
+ [ ((emptyVarSet, [(ty,ty')]), mkEqnMsg p1 p2)
+ | p2@(IParam _ ty', _) <- ips, not (ty `tcEqType` ty')]
+
+checkGroup inst_env clss@((ClassP cls _, _) : _)
+ = -- For classes life is more complicated
+ -- Suppose the class is like
+ -- classs C as | (l1 -> r1), (l2 -> r2), ... where ...
+ -- Then FOR EACH PAIR (ClassP c tys1, ClassP c tys2) in the list clss
+ -- we check whether
+ -- U l1[tys1/as] = U l2[tys2/as]
+ -- (where U is a unifier)
+ --
+ -- If so, we return the pair
+ -- U r1[tys1/as] = U l2[tys2/as]
+ --
+ -- We need to do something very similar comparing each predicate
+ -- with relevant instance decls
+ pairwise_eqns ++ instance_eqns
+
+ where
+ (cls_tvs, cls_fds) = classTvsFds cls
+ instances = inst_env cls
+
+ -- NOTE that we iterate over the fds first; they are typically
+ -- empty, which aborts the rest of the loop.
+ pairwise_eqns :: [(Equation,SDoc)]
+ pairwise_eqns -- This group comes from pairwise comparison
+ = [ (eqn, mkEqnMsg p1 p2)
+ | fd <- cls_fds,
+ p1@(ClassP _ tys1, _) : rest <- tails clss,
+ p2@(ClassP _ tys2, _) <- rest,
+ eqn <- checkClsFD emptyVarSet fd cls_tvs tys1 tys2
+ ]
+
+ instance_eqns :: [(Equation,SDoc)]
+ instance_eqns -- This group comes from comparing with instance decls
+ = [ (eqn, mkEqnMsg p1 p2)
+ | fd <- cls_fds, -- Iterate through the fundeps first,
+ -- because there often are none!
+ p2@(ClassP _ tys2, _) <- clss,
+ let rough_tcs2 = trimRoughMatchTcs cls_tvs fd (roughMatchTcs tys2),
+ ispec@(Instance { is_tvs = qtvs, is_tys = tys1,
+ is_tcs = mb_tcs1 }) <- instances,
+ not (instanceCantMatch mb_tcs1 rough_tcs2),
+ eqn <- checkClsFD qtvs fd cls_tvs tys1 tys2,
+ let p1 = (mkClassPred cls tys1,
+ ptext SLIT("arising from the instance declaration at") <+>
+ ppr (getSrcLoc ispec))
+ ]
+
+mkEqnMsg (pred1,from1) (pred2,from2)
+ = vcat [ptext SLIT("When using functional dependencies to combine"),
+ nest 2 (sep [ppr pred1 <> comma, nest 2 from1]),
+ nest 2 (sep [ppr pred2 <> comma, nest 2 from2])]
+
+----------
+checkClsFD :: TyVarSet -- Quantified type variables; see note below
+ -> FunDep TyVar -> [TyVar] -- One functional dependency from the class
+ -> [Type] -> [Type]
+ -> [Equation]
+
+checkClsFD qtvs fd clas_tvs tys1 tys2
+-- 'qtvs' are the quantified type variables, the ones which an be instantiated
+-- to make the types match. For example, given
+-- class C a b | a->b where ...
+-- instance C (Maybe x) (Tree x) where ..
+--
+-- and an Inst of form (C (Maybe t1) t2),
+-- then we will call checkClsFD with
+--
+-- qtvs = {x}, tys1 = [Maybe x, Tree x]
+-- tys2 = [Maybe t1, t2]
+--
+-- We can instantiate x to t1, and then we want to force
+-- (Tree x) [t1/x] :=: t2
+--
+-- This function is also used when matching two Insts (rather than an Inst
+-- against an instance decl. In that case, qtvs is empty, and we are doing
+-- an equality check
+--
+-- This function is also used by InstEnv.badFunDeps, which needs to *unify*
+-- For the one-sided matching case, the qtvs are just from the template,
+-- so we get matching
+--
+ = ASSERT2( length tys1 == length tys2 &&
+ length tys1 == length clas_tvs
+ , ppr tys1 <+> ppr tys2 )
+
+ case tcUnifyTys bind_fn ls1 ls2 of
+ Nothing -> []
+ Just subst | isJust (tcUnifyTys bind_fn rs1' rs2')
+ -- Don't include any equations that already hold.
+ -- Reason: then we know if any actual improvement has happened,
+ -- in which case we need to iterate the solver
+ -- In making this check we must taking account of the fact that any
+ -- qtvs that aren't already instantiated can be instantiated to anything
+ -- at all
+ -> []
+
+ | otherwise -- Aha! A useful equation
+ -> [ (qtvs', zip rs1' rs2')]
+ -- We could avoid this substTy stuff by producing the eqn
+ -- (qtvs, ls1++rs1, ls2++rs2)
+ -- which will re-do the ls1/ls2 unification when the equation is
+ -- executed. What we're doing instead is recording the partial
+ -- work of the ls1/ls2 unification leaving a smaller unification problem
+ where
+ rs1' = substTys subst rs1
+ rs2' = substTys subst rs2
+ qtvs' = filterVarSet (`notElemTvSubst` subst) qtvs
+ -- qtvs' are the quantified type variables
+ -- that have not been substituted out
+ --
+ -- Eg. class C a b | a -> b
+ -- instance C Int [y]
+ -- Given constraint C Int z
+ -- we generate the equation
+ -- ({y}, [y], z)
+ where
+ bind_fn tv | tv `elemVarSet` qtvs = BindMe
+ | otherwise = Skolem
+
+ (ls1, rs1) = instFD fd clas_tvs tys1
+ (ls2, rs2) = instFD fd clas_tvs tys2
+
+instFD :: FunDep TyVar -> [TyVar] -> [Type] -> FunDep Type
+instFD (ls,rs) tvs tys
+ = (map lookup ls, map lookup rs)
+ where
+ env = zipVarEnv tvs tys
+ lookup tv = lookupVarEnv_NF env tv
+\end{code}
+
+\begin{code}
+checkInstFDs :: ThetaType -> Class -> [Type] -> Bool
+-- Check that functional dependencies are obeyed in an instance decl
+-- For example, if we have
+-- class theta => C a b | a -> b
+-- instance C t1 t2
+-- Then we require fv(t2) `subset` oclose(fv(t1), theta)
+
+checkInstFDs theta clas inst_taus
+ = all fundep_ok fds
+ where
+ (tyvars, fds) = classTvsFds clas
+ fundep_ok fd = tyVarsOfTypes rs `subVarSet` oclose theta (tyVarsOfTypes ls)
+ where
+ (ls,rs) = instFD fd tyvars inst_taus
+\end{code}
+
+
+%************************************************************************
+%* *
+ Check that a new instance decl is OK wrt fundeps
+%* *
+%************************************************************************
+
+Here is the bad case:
+ class C a b | a->b where ...
+ instance C Int Bool where ...
+ instance C Int Char where ...
+
+The point is that a->b, so Int in the first parameter must uniquely
+determine the second. In general, given the same class decl, and given
+
+ instance C s1 s2 where ...
+ instance C t1 t2 where ...
+
+Then the criterion is: if U=unify(s1,t1) then U(s2) = U(t2).
+
+Matters are a little more complicated if there are free variables in
+the s2/t2.
+
+ class D a b c | a -> b
+ instance D a b => D [(a,a)] [b] Int
+ instance D a b => D [a] [b] Bool
+
+The instance decls don't overlap, because the third parameter keeps
+them separate. But we want to make sure that given any constraint
+ D s1 s2 s3
+if s1 matches
+
+
+\begin{code}
+checkFunDeps :: (InstEnv, InstEnv) -> Instance
+ -> Maybe [Instance] -- Nothing <=> ok
+ -- Just dfs <=> conflict with dfs
+-- Check wheher adding DFunId would break functional-dependency constraints
+-- Used only for instance decls defined in the module being compiled
+checkFunDeps inst_envs ispec
+ | null bad_fundeps = Nothing
+ | otherwise = Just bad_fundeps
+ where
+ (ins_tvs, _, clas, ins_tys) = instanceHead ispec
+ ins_tv_set = mkVarSet ins_tvs
+ cls_inst_env = classInstances inst_envs clas
+ bad_fundeps = badFunDeps cls_inst_env clas ins_tv_set ins_tys
+
+badFunDeps :: [Instance] -> Class
+ -> TyVarSet -> [Type] -- Proposed new instance type
+ -> [Instance]
+badFunDeps cls_insts clas ins_tv_set ins_tys
+ = [ ispec | fd <- fds, -- fds is often empty
+ let trimmed_tcs = trimRoughMatchTcs clas_tvs fd rough_tcs,
+ ispec@(Instance { is_tcs = mb_tcs, is_tvs = tvs,
+ is_tys = tys }) <- cls_insts,
+ -- Filter out ones that can't possibly match,
+ -- based on the head of the fundep
+ not (instanceCantMatch trimmed_tcs mb_tcs),
+ notNull (checkClsFD (tvs `unionVarSet` ins_tv_set)
+ fd clas_tvs tys ins_tys)
+ ]
+ where
+ (clas_tvs, fds) = classTvsFds clas
+ rough_tcs = roughMatchTcs ins_tys
+
+trimRoughMatchTcs :: [TyVar] -> FunDep TyVar -> [Maybe Name] -> [Maybe Name]
+-- Computing rough_tcs for a particular fundep
+-- class C a b c | a c -> b where ...
+-- For each instance .... => C ta tb tc
+-- we want to match only on the types ta, tb; so our
+-- rough-match thing must similarly be filtered.
+-- Hence, we Nothing-ise the tb type right here
+trimRoughMatchTcs clas_tvs (ltvs,_) mb_tcs
+ = zipWith select clas_tvs mb_tcs
+ where
+ select clas_tv mb_tc | clas_tv `elem` ltvs = mb_tc
+ | otherwise = Nothing
+\end{code}
+
+
+%************************************************************************
+%* *
+\subsection{Miscellaneous}
+%* *
+%************************************************************************
+
+\begin{code}
+pprFundeps :: Outputable a => [FunDep a] -> SDoc