The @FamInst@ type: family instance heads
\begin{code}
-{-# OPTIONS -w #-}
--- The above warning supression flag is a temporary kludge.
--- While working on this module you are encouraged to remove it and fix
--- any warnings in the module. See
--- http://hackage.haskell.org/trac/ghc/wiki/Commentary/CodingStyle#Warnings
--- for details
-
module FamInst (
checkFamInstConsistency, tcExtendLocalFamInstEnv
) where
import FiniteMap
import FastString
-import Maybe
+import Maybes
import Monad
\end{code}
be certain that the instances of the two modules have already been checked for
consistency during the compilation of modules that we import.
+Why do we need to check? Consider
+ module X1 where module X2 where
+ data T1 data T2
+ type instance F T1 b = Int type instance F a T2 = Char
+ f1 :: F T1 a -> Int f2 :: Char -> F a T2
+ f1 x = x f2 x = x
+
+Now if we import both X1 and X2 we could make (f2 . f1) :: Int -> Char.
+Notice that neither instance is an orphan.
+
How do we know which pairs of modules have already been checked? Any pair of
modules where both modules occur in the `HscTypes.dep_finsts' set (of the
`HscTypes.Dependencies') of one of our directly imported modules must have
-- already loaded in the EPS or they are in the HPT.
--
check modInstsEnv (ModulePair m1 m2)
- = let { instEnv1 = fromJust . lookupModuleEnv modInstsEnv $ m1
- ; instEnv2 = fromJust . lookupModuleEnv modInstsEnv $ m2
+ = let { instEnv1 = (expectJust "checkFamInstConsistency") . lookupModuleEnv modInstsEnv $ m1
+ ; instEnv2 = (expectJust "checkFamInstConsistency") . lookupModuleEnv modInstsEnv $ m2
; insts1 = famInstEnvElts instEnv1
}
in
Nothing -> panic "FamInst.checkForConflicts"
Just (tc, tys) -> tc `mkTyConApp` tys
}
- ; (tvs', _, tau') <- tcInstSkolType FamInstSkol ty
+ ; (_, _, tau') <- tcInstSkolType FamInstSkol ty
; let (fam, tys') = tcSplitTyConApp tau'
conflictInstErr famInst (head conflicts)
}
where
- -- * In the case of data family instances, any overlap is fundamentally a
+ -- - In the case of data family instances, any overlap is fundamentally a
-- conflict (as these instances imply injective type mappings).
- -- * In the case of type family instances, overlap is admitted as long as
+ -- - In the case of type family instances, overlap is admitted as long as
-- the right-hand sides of the overlapping rules coincide under the
-- overlap substitution. We require that they are syntactically equal;
-- anything else would be difficult to test for at this stage.
rhs1 = substTy subst $ synTyConType tycon1
rhs2 = substTy subst $ synTyConType tycon2
+conflictInstErr :: FamInst -> FamInst -> TcRn ()
conflictInstErr famInst conflictingFamInst
= addFamInstLoc famInst $
addErr (hang (ptext (sLit "Conflicting family instance declarations:"))
2 (pprFamInsts [famInst, conflictingFamInst]))
+addFamInstLoc :: FamInst -> TcRn a -> TcRn a
addFamInstLoc famInst thing_inside
= setSrcSpan (mkSrcSpan loc loc) thing_inside
where