X-Git-Url: http://git.megacz.com/?p=ghc-hetmet.git;a=blobdiff_plain;f=compiler%2Ftypes%2FType.lhs;h=ab47c4c8427bc8531de729bf2c75ed059ae8bc51;hp=fe707168464be6c8e9b7c172cc8d5a37b14f9811;hb=4ff3da9aa11dc1c5d00f03248dc41c7d84309fa1;hpb=f2b02ce821f793bd1ccc23f2bcbef8efc82dd38e

diff --git a/compiler/types/Type.lhs b/compiler/types/Type.lhs
index fe70716..ab47c4c 100644
--- a/compiler/types/Type.lhs
+++ b/compiler/types/Type.lhs
@@ -6,6 +6,13 @@
 Type - public interface
 
 \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 Type (
         -- re-exports from TypeRep
 	TyThing(..), Type, PredType(..), ThetaType, 
@@ -54,20 +61,22 @@ module Type (
 	applyTy, applyTys, isForAllTy, dropForAlls,
 
 	-- Source types
-	predTypeRep, mkPredTy, mkPredTys,
-	tyConOrigHead, pprSourceTyCon,
+	predTypeRep, mkPredTy, mkPredTys, pprSourceTyCon, mkFamilyTyConApp,
 
 	-- Newtypes
-	splitRecNewType_maybe, newTyConInstRhs,
+	newTyConInstRhs,
 
 	-- Lifting and boxity
-	isUnLiftedType, isUnboxedTupleType, isAlgType, isPrimitiveType,
-	isStrictType, isStrictPred, 
+	isUnLiftedType, isUnboxedTupleType, isAlgType, isClosedAlgType,
+	isPrimitiveType, isStrictType, isStrictPred, 
 
 	-- Free variables
 	tyVarsOfType, tyVarsOfTypes, tyVarsOfPred, tyVarsOfTheta,
 	typeKind, addFreeTyVars,
 
+        -- Type families
+        tyFamInsts,
+
 	-- Tidying up for printing
 	tidyType,      tidyTypes,
 	tidyOpenType,  tidyOpenTypes,
@@ -78,7 +87,7 @@ module Type (
 
 	-- Comparison
 	coreEqType, tcEqType, tcEqTypes, tcCmpType, tcCmpTypes, 
-	tcEqPred, tcCmpPred, tcEqTypeX, 
+	tcEqPred, tcCmpPred, tcEqTypeX, tcPartOfType, tcPartOfPred,
 
 	-- Seq
 	seqType, seqTypes,
@@ -89,13 +98,14 @@ module Type (
 	mkTvSubst, mkOpenTvSubst, zipOpenTvSubst, zipTopTvSubst, mkTopTvSubst, notElemTvSubst,
 	getTvSubstEnv, setTvSubstEnv, getTvInScope, extendTvInScope,
  	extendTvSubst, extendTvSubstList, isInScope, composeTvSubst, zipTyEnv,
+        isEmptyTvSubst,
 
 	-- Performing substitution on types
 	substTy, substTys, substTyWith, substTheta, 
 	substPred, substTyVar, substTyVars, substTyVarBndr, deShadowTy, lookupTyVar,
 
 	-- Pretty-printing
-	pprType, pprParendType, pprTypeApp, pprTyThingCategory, pprForAll,
+	pprType, pprParendType, pprTypeApp, pprTyThingCategory, pprTyThing, pprForAll,
 	pprPred, pprTheta, pprThetaArrow, pprClassPred, pprKind, pprParendKind
     ) where
 
@@ -122,6 +132,7 @@ import Util
 import Outputable
 import UniqSet
 
+import Data.List
 import Data.Maybe	( isJust )
 \end{code}
 
@@ -270,10 +281,12 @@ repSplitAppTy_maybe :: Type -> Maybe (Type,Type)
 -- Does the AppTy split, but assumes that any view stuff is already done
 repSplitAppTy_maybe (FunTy ty1 ty2)   = Just (TyConApp funTyCon [ty1], ty2)
 repSplitAppTy_maybe (AppTy ty1 ty2)   = Just (ty1, ty2)
-repSplitAppTy_maybe (TyConApp tc tys) = case snocView tys of
-						Just (tys', ty') -> Just (TyConApp tc tys', ty')
-						Nothing		 -> Nothing
-repSplitAppTy_maybe other = Nothing
+repSplitAppTy_maybe (TyConApp tc tys) 
+  | not (isOpenSynTyCon tc) || length tys > tyConArity tc 
+  = case snocView tys of       -- never create unsaturated type family apps
+      Just (tys', ty') -> Just (TyConApp tc tys', ty')
+      Nothing	       -> Nothing
+repSplitAppTy_maybe _other = Nothing
 -------------
 splitAppTy :: Type -> (Type, Type)
 splitAppTy ty = case splitAppTy_maybe ty of
@@ -286,7 +299,13 @@ splitAppTys ty = split ty ty []
   where
     split orig_ty ty args | Just ty' <- coreView ty = split orig_ty ty' args
     split orig_ty (AppTy ty arg)        args = split ty ty (arg:args)
-    split orig_ty (TyConApp tc tc_args) args = (TyConApp tc [], tc_args ++ args)
+    split orig_ty (TyConApp tc tc_args) args 
+      = let -- keep type families saturated
+            n | isOpenSynTyCon tc = tyConArity tc
+              | otherwise         = 0
+            (tc_args1, tc_args2)  = splitAt n tc_args
+        in
+        (TyConApp tc tc_args1, tc_args2 ++ args)
     split orig_ty (FunTy ty1 ty2)       args = ASSERT( null args )
 					       (TyConApp funTyCon [], [ty1,ty2])
     split orig_ty ty		        args = (orig_ty, args)
@@ -406,11 +425,15 @@ splitNewTyConApp_maybe (TyConApp tc tys) = Just (tc, tys)
 splitNewTyConApp_maybe (FunTy arg res)   = Just (funTyCon, [arg,res])
 splitNewTyConApp_maybe other	      = Nothing
 
--- get instantiated newtype rhs, the arguments had better saturate 
--- the constructor
 newTyConInstRhs :: TyCon -> [Type] -> Type
-newTyConInstRhs tycon tys =
-    let (tvs, ty) = newTyConRhs tycon in substTyWith tvs tys ty
+-- Unwrap one 'layer' of newtype
+-- Use the eta'd version if possible
+newTyConInstRhs tycon tys 
+    = ASSERT2( equalLength tvs tys1, ppr tycon $$ ppr tys $$ ppr tvs )
+      mkAppTys (substTyWith tvs tys1 ty) tys2
+  where
+    (tvs, ty)    = newTyConEtadRhs tycon
+    (tys1, tys2) = splitAtList tvs tys
 \end{code}
 
 
@@ -449,12 +472,15 @@ repType :: Type -> Type
 repType ty | Just ty' <- coreView ty = repType ty'
 repType (ForAllTy _ ty)  = repType ty
 repType (TyConApp tc tys)
-  | isClosedNewTyCon tc  = -- Recursive newtypes are opaque to coreView
-			   -- but we must expand them here.  Sure to
-			   -- be saturated because repType is only applied
-			   -- to types of kind *
-			   ASSERT( {- isRecursiveTyCon tc && -} tys `lengthIs` tyConArity tc )
-			   repType (new_type_rep tc tys)
+  | isNewTyCon tc
+  , (tvs, rep_ty) <- newTyConRep tc
+  = -- Recursive newtypes are opaque to coreView
+    -- but we must expand them here.  Sure to
+    -- be saturated because repType is only applied
+    -- to types of kind *
+    ASSERT( tys `lengthIs` tyConArity tc )
+    repType (substTyWith tvs tys rep_ty)
+
 repType ty = ty
 
 -- repType' aims to be a more thorough version of repType
@@ -467,12 +493,6 @@ repType' ty -- | pprTrace "repType'" (ppr ty $$ ppr (go1 ty)) False = undefined
         go ty = ty
 
 
--- new_type_rep doesn't ask any questions: 
--- it just expands newtype, whether recursive or not
-new_type_rep new_tycon tys = ASSERT( tys `lengthIs` tyConArity new_tycon )
-			     case newTyConRep new_tycon of
-				 (tvs, rep_ty) -> substTyWith tvs tys rep_ty
-
 -- ToDo: this could be moved to the code generator, using splitTyConApp instead
 -- of inspecting the type directly.
 typePrimRep :: Type -> PrimRep
@@ -487,7 +507,6 @@ typePrimRep ty = case repType ty of
 	-- The reason is that f must have kind *->*, not *->*#, because
 	-- (we claim) there is no way to constrain f's kind any other
 	-- way.
-
 \end{code}
 
 
@@ -603,20 +622,27 @@ predTypeRep (ClassP clas tys) = mkTyConApp (classTyCon clas) tys
 	-- look through that too if necessary
 predTypeRep (EqPred ty1 ty2) = pprPanic "predTypeRep" (ppr (EqPred ty1 ty2))
 
--- The original head is the tycon and its variables for a vanilla tycon and it
--- is the family tycon and its type indexes for a family instance.
-tyConOrigHead :: TyCon -> (TyCon, [Type])
-tyConOrigHead tycon = case tyConFamInst_maybe tycon of
-		        Nothing      -> (tycon, mkTyVarTys (tyConTyVars tycon))
-			Just famInst -> famInst
+mkFamilyTyConApp :: TyCon -> [Type] -> Type
+-- Given a family instance TyCon and its arg types, return the
+-- corresponding family type.  E.g.
+--	data family T a
+--	data instance T (Maybe b) = MkT b	-- Instance tycon :RTL
+-- Then 
+--	mkFamilyTyConApp :RTL Int  =  T (Maybe Int)
+mkFamilyTyConApp tc tys
+  | Just (fam_tc, fam_tys) <- tyConFamInst_maybe tc
+  , let fam_subst = zipTopTvSubst (tyConTyVars tc) tys
+  = mkTyConApp fam_tc (substTys fam_subst fam_tys)
+  | otherwise
+  = mkTyConApp tc tys
 
 -- Pretty prints a tycon, using the family instance in case of a
 -- representation tycon.  For example
 --  	e.g.  data T [a] = ...
 -- In that case we want to print `T [a]', where T is the family TyCon
 pprSourceTyCon tycon 
-  | Just (repTyCon, tys) <- tyConFamInst_maybe tycon
-  = ppr $ repTyCon `TyConApp` tys	       -- can't be FunTyCon
+  | Just (fam_tc, tys) <- tyConFamInst_maybe tycon
+  = ppr $ fam_tc `TyConApp` tys	       -- can't be FunTyCon
   | otherwise
   = ppr tycon
 \end{code}
@@ -624,34 +650,6 @@ pprSourceTyCon tycon
 
 %************************************************************************
 %*									*
-		NewTypes
-%*									*
-%************************************************************************
-
-\begin{code}
-splitRecNewType_maybe :: Type -> Maybe Type
--- Sometimes we want to look through a recursive newtype, and that's what happens here
--- It only strips *one layer* off, so the caller will usually call itself recursively
--- Only applied to types of kind *, hence the newtype is always saturated
-splitRecNewType_maybe ty | Just ty' <- coreView ty = splitRecNewType_maybe ty'
-splitRecNewType_maybe (TyConApp tc tys)
-  | isClosedNewTyCon tc
-  = ASSERT( tys `lengthIs` tyConArity tc )	-- splitRecNewType_maybe only be applied 
-						-- 	to *types* (of kind *)
-    ASSERT( isRecursiveTyCon tc ) 		-- Guaranteed by coreView
-    case newTyConRhs tc of
-	(tvs, rep_ty) -> ASSERT( length tvs == length tys )
-			 Just (substTyWith tvs tys rep_ty)
-	
-splitRecNewType_maybe other = Nothing
-
-
-
-\end{code}
-
-
-%************************************************************************
-%*									*
 \subsection{Kinds and free variables}
 %*									*
 %************************************************************************
@@ -722,6 +720,28 @@ addFreeTyVars ty			     = NoteTy (FTVNote (tyVarsOfType ty)) ty
 
 %************************************************************************
 %*									*
+\subsection{Type families}
+%*									*
+%************************************************************************
+
+Type family instances occuring in a type after expanding synonyms.
+
+\begin{code}
+tyFamInsts :: Type -> [(TyCon, [Type])]
+tyFamInsts ty 
+  | Just exp_ty <- tcView ty    = tyFamInsts exp_ty
+tyFamInsts (TyVarTy _)          = []
+tyFamInsts (TyConApp tc tys) 
+  | isOpenSynTyCon tc           = [(tc, tys)]
+  | otherwise                   = concat (map tyFamInsts tys)
+tyFamInsts (FunTy ty1 ty2)      = tyFamInsts ty1 ++ tyFamInsts ty2
+tyFamInsts (AppTy ty1 ty2)      = tyFamInsts ty1 ++ tyFamInsts ty2
+tyFamInsts (ForAllTy _ ty)      = tyFamInsts ty
+\end{code}
+
+
+%************************************************************************
+%*									*
 \subsection{TidyType}
 %*									*
 %************************************************************************
@@ -841,10 +861,19 @@ isUnboxedTupleType ty = case splitTyConApp_maybe ty of
 
 -- Should only be applied to *types*; hence the assert
 isAlgType :: Type -> Bool
-isAlgType ty = case splitTyConApp_maybe ty of
-			Just (tc, ty_args) -> ASSERT( ty_args `lengthIs` tyConArity tc )
-					      isAlgTyCon tc
-			other		   -> False
+isAlgType ty 
+  = case splitTyConApp_maybe ty of
+      Just (tc, ty_args) -> ASSERT( ty_args `lengthIs` tyConArity tc )
+			    isAlgTyCon tc
+      _other	         -> False
+
+-- Should only be applied to *types*; hence the assert
+isClosedAlgType :: Type -> Bool
+isClosedAlgType ty
+  = case splitTyConApp_maybe ty of
+      Just (tc, ty_args) -> ASSERT( ty_args `lengthIs` tyConArity tc )
+			    isAlgTyCon tc && not (isOpenTyCon tc)
+      _other	         -> False
 \end{code}
 
 @isStrictType@ computes whether an argument (or let RHS) should
@@ -987,6 +1016,29 @@ tcEqTypeX :: RnEnv2 -> Type -> Type -> Bool
 tcEqTypeX env t1 t2 = isEqual $ cmpTypeX env t1 t2
 \end{code}
 
+Checks whether the second argument is a subterm of the first.  (We don't care
+about binders, as we are only interested in syntactic subterms.)
+
+\begin{code}
+tcPartOfType :: Type -> Type -> Bool
+tcPartOfType t1              t2 
+  | tcEqType t1 t2              = True
+tcPartOfType t1              t2 
+  | Just t2' <- tcView t2       = tcPartOfType t1 t2'
+tcPartOfType _  (TyVarTy _)     = False
+tcPartOfType t1 (ForAllTy _ t2) = tcPartOfType t1 t2
+tcPartOfType t1 (AppTy s2 t2)   = tcPartOfType t1 s2 || tcPartOfType t1 t2
+tcPartOfType t1 (FunTy s2 t2)   = tcPartOfType t1 s2 || tcPartOfType t1 t2
+tcPartOfType t1 (PredTy p2)     = tcPartOfPred t1 p2
+tcPartOfType t1 (TyConApp _ ts) = any (tcPartOfType t1) ts
+tcPartOfType t1 (NoteTy _ t2)   = tcPartOfType t1 t2
+
+tcPartOfPred :: Type -> PredType -> Bool
+tcPartOfPred t1 (IParam _ t2)  = tcPartOfType t1 t2
+tcPartOfPred t1 (ClassP _ ts)  = any (tcPartOfType t1) ts
+tcPartOfPred t1 (EqPred s2 t2) = tcPartOfType t1 s2 || tcPartOfType t1 t2
+\end{code}
+
 Now here comes the real worker
 
 \begin{code}
@@ -1220,7 +1272,7 @@ zipTopTvSubst :: [TyVar] -> [Type] -> TvSubst
 zipTopTvSubst tyvars tys 
 #ifdef DEBUG
   | length tyvars /= length tys
-  = pprTrace "zipOpenTvSubst" (ppr tyvars $$ ppr tys) emptyTvSubst
+  = pprTrace "zipTopTvSubst" (ppr tyvars $$ ppr tys) emptyTvSubst
   | otherwise
 #endif
   = TvSubst emptyInScopeSet (zipTyEnv tyvars tys)
@@ -1493,8 +1545,6 @@ isSuperKind other = False
 isKind :: Kind -> Bool
 isKind k = isSuperKind (typeKind k)
 
-
-
 isSubKind :: Kind -> Kind -> Bool
 -- (k1 `isSubKind` k2) checks that k1 <: k2
 isSubKind (TyConApp kc1 []) (TyConApp kc2 []) = kc1 `isSubKindCon` kc2