X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypes%2FFunDeps.lhs;h=949cac489e3eca9ce861d93008f3a72e00a8786f;hb=ebc623f8daba6bc027c625d333d28ff2ccd630cf;hp=30549dd62b1e82f8a6edebf6480ca44d5cf4a2ea;hpb=0f5731ee92009fe43e9cc0bd276b4562e0c37089;p=ghc-hetmet.git

diff --git a/compiler/types/FunDeps.lhs b/compiler/types/FunDeps.lhs
index 30549dd..949cac4 100644
--- a/compiler/types/FunDeps.lhs
+++ b/compiler/types/FunDeps.lhs
@@ -20,13 +20,15 @@ module FunDeps (
 import Name
 import Var
 import Class
-import TcGadt
 import TcType
+import Unify
 import InstEnv
 import VarSet
 import VarEnv
 import Outputable
 import Util
+import FastString
+
 import Data.Maybe	( isJust )
 \end{code}
 
@@ -76,21 +78,29 @@ uniform thing is to return {t}.
 
 However, consider
 	class D a b c | b->c
-	f x = e	  -- Generates constraint (D s Int t)
+	f x = e	  -- 'e' generates constraint (D s Int t)
 		  -- \x.e has type s->s
 Then, if (oclose (D s Int t) {}) = {t}, we'll make the function
 monomorphic in 't', thus
 	f :: forall s. D s Int t => s -> s
 
-But if this function is never called, t will never be instantiated;
-the functional dependencies that fix t may well be instance decls in
+But if this function is never called, 't' will never be instantiated;
+the functional dependencies that fix 't' may well be instance decls in
 some importing module.  But the top-level defaulting of unconstrained
-type variales will fix t=GHC.Prim.Any, and that's simply a bug.
+type variables will fix t=GHC.Prim.Any, and that's simply a bug.
 
 Conclusion: oclose only returns a type variable as "fixed" if it 
 depends on at least one type variable in the input fixed_tvs.
 
 Remember, it's always sound for oclose to return a smaller set.
+An interesting example is tcfail093, where we get this inferred type:
+    class C a b | a->b
+    dup :: forall h. (Call (IO Int) h) => () -> Int -> h
+This is perhaps a bit silly, because 'h' is fixed by the (IO Int);
+previously GHC rejected this saying 'no instance for Call (IO Int) h'.
+But it's right on the borderline. If there was an extra, otherwise
+uninvolved type variable, like 's' in the type of 'f' above, then
+we must accept the function.  So, for now anyway, we accept 'dup' too.
 
 \begin{code}
 oclose :: [PredType] -> TyVarSet -> TyVarSet
@@ -138,7 +148,7 @@ See also Note [Ambiguity] in TcSimplify
 \begin{code}
 grow :: [PredType] -> TyVarSet -> TyVarSet
 grow preds fixed_tvs 
-  | null preds = real_fixed_tvs
+  | null preds = fixed_tvs
   | otherwise  = loop real_fixed_tvs
   where
 	-- Add the implicit parameters; 
@@ -189,9 +199,10 @@ type Equation = (TyVarSet, [(Type, Type)])
 -- We usually act on an equation by instantiating the quantified type varaibles
 -- to fresh type variables, and then calling the standard unifier.
 
+pprEquation :: Equation -> SDoc
 pprEquation (qtvs, pairs) 
-  = vcat [ptext SLIT("forall") <+> braces (pprWithCommas ppr (varSetElems qtvs)),
-	  nest 2 (vcat [ ppr t1 <+> ptext SLIT(":=:") <+> ppr t2 | (t1,t2) <- pairs])]
+  = vcat [ptext (sLit "forall") <+> braces (pprWithCommas ppr (varSetElems qtvs)),
+	  nest 2 (vcat [ ppr t1 <+> ptext (sLit ":=:") <+> ppr t2 | (t1,t2) <- pairs])]
 \end{code}
 
 Given a bunch of predicates that must hold, such as
@@ -235,7 +246,7 @@ improveOne :: (Class -> [Instance])		-- Gives instances for given class
 						-- combined (for error messages)
 -- Just do improvement triggered by a single, distinguised predicate
 
-improveOne inst_env pred@(IParam ip ty, _) preds
+improveOne _inst_env pred@(IParam ip ty, _) preds
   = [ ((emptyVarSet, [(ty,ty2)]), pred, p2) 
     | p2@(IParam ip2 ty2, _) <- preds
     , ip==ip2
@@ -282,11 +293,11 @@ improveOne inst_env pred@(ClassP cls tys, _) preds
 	, not (instanceCantMatch inst_tcs trimmed_tcs)
 	, eqn <- checkClsFD qtvs fd cls_tvs tys_inst tys
 	, let p_inst = (mkClassPred cls tys_inst, 
-		        ptext SLIT("arising from the instance declaration at")
+		        ptext (sLit "arising from the instance declaration at")
 			<+> ppr (getSrcLoc ispec))
 	]
 
-improveOne inst_env eq_pred preds
+improveOne _ _ _
   = []