X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=compiler%2Ftypes%2FCoercion.lhs;h=fa4a6b7340a92d6b80e28f366a4e2cf4b16ce829;hb=25f84fa7e4b84c3db5ba745a7881c009b778e0b1;hp=49ae740c7009ce6a7a09101099b086aec8dfa808;hpb=13cd965d80be5c25dc54534a833df39ab7aa7a12;p=ghc-hetmet.git diff --git a/compiler/types/Coercion.lhs b/compiler/types/Coercion.lhs index 49ae740..fa4a6b7 100644 --- a/compiler/types/Coercion.lhs +++ b/compiler/types/Coercion.lhs @@ -12,6 +12,13 @@ The coercion kind constructor is a special TyCon that must always be saturated typeKind (symCoercion type) :: TyConApp CoercionTyCon{...} [type, type] \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 Coercion ( Coercion, @@ -22,16 +29,28 @@ module Coercion ( isEqPred, mkEqPred, getEqPredTys, isEqPredTy, -- Coercion transformations + mkCoercion, mkSymCoercion, mkTransCoercion, - mkLeftCoercion, mkRightCoercion, mkInstCoercion, mkAppCoercion, + mkLeftCoercion, mkRightCoercion, mkRightCoercions, + mkInstCoercion, mkAppCoercion, mkForAllCoercion, mkFunCoercion, mkInstsCoercion, mkUnsafeCoercion, mkNewTypeCoercion, mkFamInstCoercion, mkAppsCoercion, - splitNewTypeRepCo_maybe, decomposeCo, + splitNewTypeRepCo_maybe, instNewTyCon_maybe, decomposeCo, unsafeCoercionTyCon, symCoercionTyCon, transCoercionTyCon, leftCoercionTyCon, - rightCoercionTyCon, instCoercionTyCon -- needed by TysWiredIn + rightCoercionTyCon, instCoercionTyCon, -- needed by TysWiredIn + + -- CoercionI + CoercionI(..), + isIdentityCoercion, + mkSymCoI, mkTransCoI, + mkTyConAppCoI, mkAppTyCoI, mkFunTyCoI, + mkNoteTyCoI, mkForAllTyCoI, + fromCoI, fromACo, + mkClassPPredCoI, mkIParamPredCoI, mkEqPredCoI + ) where #include "HsVersions.h" @@ -39,6 +58,7 @@ module Coercion ( import TypeRep import Type import TyCon +import Class import Var import Name import OccName @@ -49,6 +69,9 @@ import BasicTypes import Outputable +type Coercion = Type +type CoercionKind = Kind -- A CoercionKind is always of form (ty1 :=: ty2) + ------------------------------ decomposeCo :: Arity -> Coercion -> [Coercion] -- (decomposeCo 3 c) = [right (left (left c)), right (left c), right c] @@ -91,9 +114,6 @@ splitCoercionKind_maybe co | Just co' <- kindView co = splitCoercionKind_maybe c splitCoercionKind_maybe (PredTy (EqPred ty1 ty2)) = Just (ty1, ty2) splitCoercionKind_maybe other = Nothing -type Coercion = Type -type CoercionKind = Kind -- A CoercionKind is always of form (ty1 :=: ty2) - coercionKind :: Coercion -> (Type, Type) -- c :: (t1 :=: t2) -- Then (coercionKind c) = (t1,t2) @@ -216,6 +236,17 @@ mkRightCoercion co | Just (co1, co2) <- splitAppCoercion_maybe co = co2 | otherwise = mkCoercion rightCoercionTyCon [co] +mkRightCoercions n co + = go n co [] + where + go n co acc + | n > 0 + = case splitAppCoercion_maybe co of + Just (co1,co2) -> go (n-1) co1 (co2:acc) + Nothing -> go (n-1) (mkCoercion leftCoercionTyCon [co]) (mkCoercion rightCoercionTyCon [co]:acc) + | otherwise + = acc + mkInstCoercion co ty | Just (tv,co') <- splitForAllTy_maybe co = substTyWith [tv] [ty] co' -- (forall a.co) @ ty --> co[ty/a] @@ -402,22 +433,117 @@ unsafeCoercionTyConName = mkCoConName FSLIT("CoUnsafe") unsafeCoercionTyConKey u +instNewTyCon_maybe :: TyCon -> [Type] -> Maybe (Type, CoercionI) +-- instNewTyCon_maybe T ts +-- = Just (rep_ty, co) if co : T ts ~ rep_ty +instNewTyCon_maybe tc tys + | Just (tvs, ty, mb_co_tc) <- unwrapNewTyCon_maybe tc + = ASSERT( tys `lengthIs` tyConArity tc ) + Just (substTyWith tvs tys ty, + case mb_co_tc of + Nothing -> IdCo + Just co_tc -> ACo (mkTyConApp co_tc tys)) + | otherwise + = Nothing + -- this is here to avoid module loops splitNewTypeRepCo_maybe :: Type -> Maybe (Type, Coercion) -- Sometimes we want to look through a newtype and get its associated coercion -- 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 +-- splitNewTypeRepCo_maybe ty +-- = Just (ty', co) if co : ty ~ ty' +-- Returns Nothing for non-newtypes or fully-transparent newtypes splitNewTypeRepCo_maybe ty | Just ty' <- coreView ty = splitNewTypeRepCo_maybe ty' splitNewTypeRepCo_maybe (TyConApp tc tys) - | isClosedNewTyCon tc - = ASSERT( tys `lengthIs` tyConArity tc ) -- splitNewTypeRepCo_maybe only be applied - -- to *types* (of kind *) - case newTyConRhs tc of - (tvs, rep_ty) -> - ASSERT( length tvs == length tys ) - Just (substTyWith tvs tys rep_ty, mkTyConApp co_con tys) - where - co_con = maybe (pprPanic "splitNewTypeRepCo_maybe" (ppr tc)) id (newTyConCo_maybe tc) -splitNewTypeRepCo_maybe other = Nothing + | Just (ty', coi) <- instNewTyCon_maybe tc tys + = case coi of + ACo co -> Just (ty', co) + IdCo -> panic "splitNewTypeRepCo_maybe" + -- This case handled by coreView +splitNewTypeRepCo_maybe other + = Nothing \end{code} + + +-------------------------------------- +-- CoercionI smart constructors +-- lifted smart constructors of ordinary coercions + +\begin{code} + -- CoercionI is either + -- (a) proper coercion + -- (b) the identity coercion +data CoercionI = IdCo | ACo Coercion + +isIdentityCoercion :: CoercionI -> Bool +isIdentityCoercion IdCo = True +isIdentityCoercion _ = False + +allIdCos :: [CoercionI] -> Bool +allIdCos = all isIdentityCoercion + +zipCoArgs :: [CoercionI] -> [Type] -> [Coercion] +zipCoArgs cois tys = zipWith fromCoI cois tys + +fromCoI :: CoercionI -> Type -> Type +fromCoI IdCo ty = ty -- Identity coercion represented +fromCoI (ACo co) ty = co -- by the type itself + +mkSymCoI :: CoercionI -> CoercionI +mkSymCoI IdCo = IdCo +mkSymCoI (ACo co) = ACo $ mkCoercion symCoercionTyCon [co] + -- the smart constructor + -- is too smart with tyvars + +mkTransCoI :: CoercionI -> CoercionI -> CoercionI +mkTransCoI IdCo aco = aco +mkTransCoI aco IdCo = aco +mkTransCoI (ACo co1) (ACo co2) = ACo $ mkTransCoercion co1 co2 + +mkTyConAppCoI :: TyCon -> [Type] -> [CoercionI] -> CoercionI +mkTyConAppCoI tyCon tys cois + | allIdCos cois = IdCo + | otherwise = ACo (TyConApp tyCon (zipCoArgs cois tys)) + +mkAppTyCoI :: Type -> CoercionI -> Type -> CoercionI -> CoercionI +mkAppTyCoI ty1 IdCo ty2 IdCo = IdCo +mkAppTyCoI ty1 coi1 ty2 coi2 = + ACo $ AppTy (fromCoI coi1 ty1) (fromCoI coi2 ty2) + +mkFunTyCoI :: Type -> CoercionI -> Type -> CoercionI -> CoercionI +mkFunTyCoI ty1 IdCo ty2 IdCo = IdCo +mkFunTyCoI ty1 coi1 ty2 coi2 = + ACo $ FunTy (fromCoI coi1 ty1) (fromCoI coi2 ty2) + +mkNoteTyCoI :: TyNote -> CoercionI -> CoercionI +mkNoteTyCoI _ IdCo = IdCo +mkNoteTyCoI note (ACo co) = ACo $ NoteTy note co + +mkForAllTyCoI :: TyVar -> CoercionI -> CoercionI +mkForAllTyCoI _ IdCo = IdCo +mkForAllTyCoI tv (ACo co) = ACo $ ForAllTy tv co + +fromACo (ACo co) = co + + +mkClassPPredCoI :: Class -> [Type] -> [CoercionI] -> CoercionI +-- mkClassPPredCoI cls tys cois = coi +-- coi : PredTy (cls tys) ~ predTy (cls (tys `cast` cois)) +mkClassPPredCoI cls tys cois + | allIdCos cois = IdCo + | otherwise = ACo $ PredTy $ ClassP cls (zipCoArgs cois tys) + +mkIParamPredCoI :: (IPName Name) -> CoercionI -> CoercionI +-- Similar invariant to mkclassPPredCoI +mkIParamPredCoI ipn IdCo = IdCo +mkIParamPredCoI ipn (ACo co) = ACo $ PredTy $ IParam ipn co + +mkEqPredCoI :: Type -> CoercionI -> Type -> CoercionI -> CoercionI +-- Similar invariant to mkclassPPredCoI +mkEqPredCoI _ IdCo _ IdCo = IdCo +mkEqPredCoI ty1 IdCo _ (ACo co2) = ACo $ PredTy $ EqPred ty1 co2 +mkEqPredCoI ty1 (ACo co1) ty2 coi2 = ACo $ PredTy $ EqPred co1 (fromCoI coi2 ty2) +\end{code} +