X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypes%2FFamInstEnv.lhs;h=8751e40cef8e38f9bc8dcf1d5cd0b363f61048d6;hb=923ee9d360ed15331ac6faf8a6b4aca334fc0cee;hp=b8c82f862328f79e1e7a0af7fcfe43cf946002dc;hpb=4899cc823373bd016a49cdb0dffd0e22150ec07e;p=ghc-hetmet.git

diff --git a/compiler/types/FamInstEnv.lhs b/compiler/types/FamInstEnv.lhs
index b8c82f8..8751e40 100644
--- a/compiler/types/FamInstEnv.lhs
+++ b/compiler/types/FamInstEnv.lhs
@@ -10,11 +10,14 @@ module FamInstEnv (
 	pprFamInst, pprFamInstHdr, pprFamInsts, 
 	famInstHead, mkLocalFamInst, mkImportedFamInst,
 
-	FamInstEnvs, FamInstEnv, emptyFamInstEnv, 
+	FamInstEnvs, FamInstEnv, emptyFamInstEnv, emptyFamInstEnvs, 
 	extendFamInstEnv, extendFamInstEnvList, 
 	famInstEnvElts, familyInstances,
 
-	lookupFamInstEnv, lookupFamInstEnvUnify
+	lookupFamInstEnv, lookupFamInstEnvUnify,
+	
+	-- Normalisation
+	topNormaliseType
     ) where
 
 #include "HsVersions.h"
@@ -24,7 +27,9 @@ import Unify
 import TcGadt
 import TcType
 import Type
+import TypeRep
 import TyCon
+import Coercion
 import VarSet
 import Var
 import Name
@@ -32,6 +37,8 @@ import OccName
 import SrcLoc
 import UniqFM
 import Outputable
+import Maybes
+import Util
 
 import Maybe
 \end{code}
@@ -161,6 +168,9 @@ data FamilyInstEnv
 --  * The fs_tvs are distinct in each FamInst
 --	of a range value of the map (so we can safely unify them)
 
+emptyFamInstEnvs :: (FamInstEnv, FamInstEnv)
+emptyFamInstEnvs = (emptyFamInstEnv, emptyFamInstEnv)
+
 emptyFamInstEnv :: FamInstEnv
 emptyFamInstEnv = emptyUFM
 
@@ -189,7 +199,7 @@ extendFamInstEnv inst_env ins_item@(FamInst {fi_fam = cls_nm, fi_tcs = mb_tcs})
 
 %************************************************************************
 %*									*
-\subsection{Looking up a family instance}
+		Looking up a family instance
 %*									*
 %************************************************************************
 
@@ -217,6 +227,9 @@ lookupFamInstEnv :: FamInstEnvs
 	         -> TyCon -> [Type]		-- What we are looking for
 	         -> [FamInstMatch] 	        -- Successful matches
 lookupFamInstEnv (pkg_ie, home_ie) fam tys
+  | not (isOpenTyCon fam) 
+  = []
+  | otherwise
   = home_matches ++ pkg_matches
   where
     rough_tcs    = roughMatchTcs tys
@@ -266,6 +279,9 @@ indexed synonyms and we don't want to slow that down by needless unification.
 lookupFamInstEnvUnify :: (FamInstEnv, FamInstEnv) -> TyCon -> [Type]
 	              -> [(FamInstMatch)]
 lookupFamInstEnvUnify (pkg_ie, home_ie) fam tys
+  | not (isOpenTyCon fam) 
+  = []
+  | otherwise
   = home_matches ++ pkg_matches
   where
     rough_tcs    = roughMatchTcs tys
@@ -310,3 +326,95 @@ lookupFamInstEnvUnify (pkg_ie, home_ie) fam tys
 bind_fn tv | isTcTyVar tv && isExistentialTyVar tv = Skolem
 	   | otherwise	 		 	   = BindMe
 \end{code}
+
+%************************************************************************
+%*									*
+		Looking up a family instance
+%*									*
+%************************************************************************
+
+\begin{code}
+topNormaliseType :: FamInstEnvs
+		      -> Type
+	   	      -> Maybe (Coercion, Type)
+
+-- Get rid of *outermost* (or toplevel) type functions by rewriting them
+-- By "outer" we mean that toplevelNormaliseType guarantees to return
+-- a type that does not have a reducible redex (F ty1 .. tyn) as its
+-- outermost form.  It *can* return something like (Maybe (F ty)), where
+-- (F ty) is a redex.
+
+topNormaliseType env ty
+  | Just ty' <- tcView ty = topNormaliseType env ty'
+
+topNormaliseType env ty@(TyConApp tc tys)
+  | isOpenTyCon tc
+  , (ACo co, ty) <- normaliseType env ty
+  = Just (co, ty)
+
+topNormaliseType env ty
+  = Nothing
+	 
+
+normaliseType :: FamInstEnvs 		-- environment with family instances
+	      -> Type  			-- old type
+	      -> (CoercionI,Type)	-- (coercion,new type), where
+					-- co :: old-type ~ new_type
+-- Normalise the input type, by eliminating all type-function redexes
+
+normaliseType env ty 
+  | Just ty' <- coreView ty = normaliseType env ty' 
+
+normaliseType env ty@(TyConApp tyCon tys)
+  = let	-- First normalise the arg types
+	(cois, ntys) = mapAndUnzip (normaliseType env) tys
+	tycon_coi    = mkTyConAppCoI tyCon ntys cois
+    in 	-- Now try the top-level redex
+    case lookupFamInstEnv env tyCon ntys of
+		-- A matching family instance exists
+	[(fam_inst, tys)] -> (fix_coi, nty)
+	    where
+		rep_tc         = famInstTyCon fam_inst
+		co_tycon       = expectJust "lookupFamInst" (tyConFamilyCoercion_maybe rep_tc)
+		co	       = mkTyConApp co_tycon tys
+		first_coi      = mkTransCoI tycon_coi (ACo co)
+		(rest_coi,nty) = normaliseType env (mkTyConApp rep_tc tys)
+		fix_coi        = mkTransCoI first_coi rest_coi
+
+		-- No unique matching family instance exists;
+		-- we do not do anything
+	other -> (tycon_coi, TyConApp tyCon ntys)
+
+  where
+
+normaliseType env ty@(AppTy ty1 ty2)
+  =	let (coi1,nty1) = normaliseType env ty1
+	    (coi2,nty2) = normaliseType env ty2
+	in  (mkAppTyCoI nty1 coi1 nty2 coi2, AppTy nty1 nty2)
+normaliseType env ty@(FunTy ty1 ty2)
+  =	let (coi1,nty1) = normaliseType env ty1
+	    (coi2,nty2) = normaliseType env ty2
+	in  (mkFunTyCoI nty1 coi1 nty2 coi2, FunTy nty1 nty2)
+normaliseType env ty@(ForAllTy tyvar ty1)
+  =	let (coi,nty1) = normaliseType env ty1
+	in  (mkForAllTyCoI tyvar coi,ForAllTy tyvar nty1)
+normaliseType env ty@(NoteTy note ty1)
+  =	let (coi,nty1) = normaliseType env ty1
+	in  (mkNoteTyCoI note coi,NoteTy note nty1)
+normaliseType env ty@(TyVarTy _)
+  =	(IdCo,ty)
+normaliseType env (PredTy predty)
+  =	normalisePred env predty	
+
+normalisePred :: FamInstEnvs -> PredType -> (CoercionI,Type)
+normalisePred env (ClassP cls tys)
+  =	let (cois,tys') = mapAndUnzip (normaliseType env) tys
+	in  (mkClassPPredCoI cls tys' cois, PredTy $ ClassP cls tys')
+normalisePred env (IParam ipn ty)
+  = 	let (coi,ty') = normaliseType env ty
+	in  (mkIParamPredCoI ipn coi, PredTy $ IParam ipn ty')
+normalisePred env (EqPred ty1 ty2)
+  = 	let (coi1,ty1') = normaliseType env ty1
+            (coi2,ty2') = normaliseType env ty2
+	in  (mkEqPredCoI ty1' coi1 ty2' coi2, PredTy $ EqPred ty1' ty2')
+\end{code}