X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypes%2FType.lhs;h=56decc5a0be0aa041f3193750f858dd7b6ac0177;hb=438596897ebbe25a07e1c82085cfbc5bdb00f09e;hp=e7774150be31c65185b3f4e79934a8d9d8ba36d0;hpb=5cf27e8f1731c52fe63a5b9615f927484164c61b;p=ghc-hetmet.git diff --git a/ghc/compiler/types/Type.lhs b/ghc/compiler/types/Type.lhs index e777415..56decc5 100644 --- a/ghc/compiler/types/Type.lhs +++ b/ghc/compiler/types/Type.lhs @@ -1,875 +1,898 @@ \begin{code} -#include "HsVersions.h" - module Type ( - GenType(..), Type(..), TauType(..), - mkTyVarTy, mkTyVarTys, - getTyVar, getTyVar_maybe, isTyVarTy, - mkAppTy, mkAppTys, splitAppTy, - mkFunTy, mkFunTys, splitFunTy, splitFunTyExpandingDicts, - getFunTy_maybe, getFunTyExpandingDicts_maybe, - mkTyConTy, getTyCon_maybe, applyTyCon, - mkSynTy, - mkForAllTy, mkForAllTys, getForAllTy_maybe, splitForAllTy, - mkForAllUsageTy, getForAllUsageTy, - applyTy, -#ifdef DEBUG - expandTy, -- only let out for debugging (ToDo: rm?) -#endif - isPrimType, isUnboxedType, typePrimRep, - - RhoType(..), SigmaType(..), ThetaType(..), - mkDictTy, - mkRhoTy, splitRhoTy, mkTheta, - mkSigmaTy, splitSigmaTy, + GenType(..), TyNote(..), -- Representation visible to friends + Type, GenKind, Kind, + TyVarSubst, GenTyVarSubst, + + funTyCon, boxedKindCon, unboxedKindCon, openKindCon, + + boxedTypeKind, unboxedTypeKind, openTypeKind, mkArrowKind, mkArrowKinds, + hasMoreBoxityInfo, superKind, + + mkTyVarTy, mkTyVarTys, getTyVar, getTyVar_maybe, isTyVarTy, - maybeAppTyCon, getAppTyCon, - maybeAppDataTyCon, getAppDataTyCon, getAppSpecDataTyCon, - maybeAppDataTyConExpandingDicts, maybeAppSpecDataTyConExpandingDicts, - getAppDataTyConExpandingDicts, getAppSpecDataTyConExpandingDicts, - maybeBoxedPrimType, + mkAppTy, mkAppTys, splitAppTy, splitAppTys, splitAppTy_maybe, - matchTy, matchTys, eqTy, eqSimpleTy, eqSimpleTheta, + mkFunTy, mkFunTys, splitFunTy_maybe, splitFunTys, funResultTy, - instantiateTy, instantiateTauTy, instantiateUsage, - applyTypeEnvToTy, + mkTyConApp, mkTyConTy, splitTyConApp_maybe, + splitAlgTyConApp_maybe, splitAlgTyConApp, + mkDictTy, splitDictTy_maybe, isDictTy, + mkSynTy, isSynTy, + + mkForAllTy, mkForAllTys, splitForAllTy_maybe, splitForAllTys, + applyTy, applyTys, isForAllTy, + mkPiType, + + TauType, RhoType, SigmaType, ThetaType, isTauTy, + mkRhoTy, splitRhoTy, + mkSigmaTy, splitSigmaTy, + + isUnLiftedType, isUnboxedType, isUnboxedTupleType, isAlgType, + typePrimRep, + + tyVarsOfType, tyVarsOfTypes, namesOfType, typeKind, + addFreeTyVars, + + substTy, fullSubstTy, substTyVar, + substFlexiTy, substFlexiTheta, - tyVarsOfType, tyVarsOfTypes, typeKind + showTypeCategory ) where -import Ubiq -import IdLoop -- for paranoia checking -import TyLoop -- for paranoia checking -import PrelLoop -- for paranoia checking +#include "HsVersions.h" --- ToDo:rm ---import PprType ( pprGenType ) -- ToDo: rm ---import PprStyle ( PprStyle(..) ) ---import Util ( pprPanic ) +import {-# SOURCE #-} DataCon( DataCon ) -- friends: -import Class ( classSig, classOpLocalType, GenClass{-instances-} ) -import Kind ( mkBoxedTypeKind, resultKind ) -import TyCon ( mkFunTyCon, mkTupleTyCon, isFunTyCon, isPrimTyCon, isDataTyCon, isSynTyCon, tyConArity, - tyConKind, tyConDataCons, getSynTyConDefn, TyCon ) -import TyVar ( tyVarKind, GenTyVar{-instances-}, GenTyVarSet(..), - emptyTyVarSet, unionTyVarSets, minusTyVarSet, - unitTyVarSet, nullTyVarEnv, lookupTyVarEnv, - addOneToTyVarEnv, TyVarEnv(..) ) -import Usage ( usageOmega, GenUsage, Usage(..), UVar(..), UVarEnv(..), - nullUVarEnv, addOneToUVarEnv, lookupUVarEnv, eqUVar, - eqUsage ) +import Var ( Id, TyVar, GenTyVar, IdOrTyVar, + removeTyVarFlexi, + tyVarKind, isId, idType + ) +import VarEnv +import VarSet --- others -import Maybes ( maybeToBool ) -import PrimRep ( PrimRep(..) ) -import Util ( thenCmp, zipEqual, panic, panic#, assertPanic, pprTrace{-ToDo:rm-}, pprPanic{-ToDo:rm-}, - Ord3(..){-instances-} +import Name ( NamedThing(..), Provenance(..), ExportFlag(..), + mkWiredInTyConName, mkGlobalName, varOcc ) --- ToDo:rm all these -import {-mumble-} - Pretty -import {-mumble-} - PprStyle -import {-mumble-} - PprType (pprType ) -import {-mumble-} - UniqFM (ufmToList ) -import {-mumble-} - Unique (pprUnique ) +import NameSet +import Class ( classTyCon, Class ) +import TyCon ( TyCon, Boxity(..), + mkFunTyCon, mkKindCon, superKindCon, + matchesTyCon, isUnboxedTupleTyCon, isUnLiftedTyCon, + isFunTyCon, isEnumerationTyCon, + isTupleTyCon, maybeTyConSingleCon, + isPrimTyCon, isAlgTyCon, isSynTyCon, tyConArity, + tyConKind, tyConDataCons, getSynTyConDefn, + tyConPrimRep, tyConClass_maybe + ) + +-- others +import BasicTypes ( Unused ) +import SrcLoc ( mkBuiltinSrcLoc ) +import PrelMods ( pREL_GHC ) +import Maybes ( maybeToBool ) +import PrimRep ( PrimRep(..), isFollowableRep ) +import Unique -- quite a few *Keys +import Util ( thenCmp ) +import Outputable + \end{code} -Data types -~~~~~~~~~~ +%************************************************************************ +%* * +\subsection{Type Classifications} +%* * +%************************************************************************ + +A type is + + *unboxed* iff its representation is other than a pointer + Unboxed types cannot instantiate a type variable + Unboxed types are always unlifted. + + *lifted* A type is lifted iff it has bottom as an element. + Closures always have lifted types: i.e. any + let-bound identifier in Core must have a lifted + type. Operationally, a lifted object is one that + can be entered. + (NOTE: previously "pointed"). + + *algebraic* A type with one or more constructors. An algebraic + type is one that can be deconstructed with a case + expression. *NOT* the same as lifted types, + because we also include unboxed tuples in this + classification. + + *primitive* iff it is a built-in type that can't be expressed + in Haskell. + +Currently, all primitive types are unlifted, but that's not necessarily +the case. (E.g. Int could be primitive.) + +Some primitive types are unboxed, such as Int#, whereas some are boxed +but unlifted (such as ByteArray#). The only primitive types that we +classify as algebraic are the unboxed tuples. + +examples of type classifications: + +Type primitive boxed lifted algebraic +----------------------------------------------------------------------------- +Int#, Yes No No No +ByteArray# Yes Yes No No +(# a, b #) Yes No No Yes +( a, b ) No Yes Yes Yes +[a] No Yes Yes Yes + +%************************************************************************ +%* * +\subsection{The data type} +%* * +%************************************************************************ + \begin{code} -type Type = GenType TyVar UVar -- Used after typechecker +type Type = GenType Unused -- Used after typechecker -data GenType tyvar uvar -- Parameterised over type and usage variables - = TyVarTy tyvar +type GenKind flexi = GenType flexi +type Kind = Type + +type TyVarSubst = TyVarEnv Type +type GenTyVarSubst flexi = TyVarEnv (GenType flexi) + +data GenType flexi -- Parameterised over the "flexi" part of a type variable + = TyVarTy (GenTyVar flexi) | AppTy - (GenType tyvar uvar) - (GenType tyvar uvar) + (GenType flexi) -- Function is *not* a TyConApp + (GenType flexi) + + | TyConApp -- Application of a TyCon + TyCon -- *Invariant* saturated appliations of FunTyCon and + -- synonyms have their own constructors, below. + [GenType flexi] -- Might not be saturated. - | TyConTy -- Constants of a specified kind - TyCon -- Must *not* be a SynTyCon - (GenUsage uvar) -- Usage gives uvar of the full application, - -- iff the full application is of kind Type - -- c.f. the Usage field in TyVars + | FunTy -- Special case of TyConApp: TyConApp FunTyCon [t1,t2] + (GenType flexi) + (GenType flexi) - | SynTy -- Synonyms must be saturated, and contain their expansion - TyCon -- Must be a SynTyCon - [GenType tyvar uvar] - (GenType tyvar uvar) -- Expansion! + | NoteTy -- Saturated application of a type synonym + (TyNote flexi) + (GenType flexi) -- The expanded version | ForAllTy - tyvar - (GenType tyvar uvar) -- TypeKind - - | ForAllUsageTy - uvar -- Quantify over this - [uvar] -- Bounds; the quantified var must be - -- less than or equal to all these - (GenType tyvar uvar) - - -- Two special cases that save a *lot* of administrative - -- overhead: - - | FunTy -- BoxedTypeKind - (GenType tyvar uvar) -- Both args are of TypeKind - (GenType tyvar uvar) - (GenUsage uvar) - - | DictTy -- TypeKind - Class -- Class - (GenType tyvar uvar) -- Arg has kind TypeKind - (GenUsage uvar) + (GenTyVar flexi) + (GenType flexi) -- TypeKind + +data TyNote flexi + = SynNote (GenType flexi) -- The unexpanded version of the type synonym; always a TyConApp + | FTVNote (GenTyVarSet flexi) -- The free type variables of the noted expression +\end{code} + + +%************************************************************************ +%* * +\subsection{Wired-in type constructors +%* * +%************************************************************************ + +We define a few wired-in type constructors here to avoid module knots + +\begin{code} +funTyConName = mkWiredInTyConName funTyConKey pREL_GHC SLIT("->") funTyCon +funTyCon = mkFunTyCon funTyConName (mkArrowKinds [boxedTypeKind, boxedTypeKind] boxedTypeKind) \end{code} \begin{code} -type RhoType = Type -type TauType = Type -type ThetaType = [(Class, Type)] -type SigmaType = Type +mk_kind_name key str = mkGlobalName key pREL_GHC (varOcc str) + (LocalDef mkBuiltinSrcLoc NotExported) + -- mk_kind_name is a bit of a hack + -- The LocalDef means that we print the name without + -- a qualifier, which is what we want for these kinds. + +boxedKindConName = mk_kind_name boxedKindConKey SLIT("*") +boxedKindCon = mkKindCon boxedKindConName superKind Boxed + +unboxedKindConName = mk_kind_name unboxedKindConKey SLIT("*#") +unboxedKindCon = mkKindCon unboxedKindConName superKind Unboxed + +openKindConName = mk_kind_name openKindConKey SLIT("*?") +openKindCon = mkKindCon openKindConName superKind Open \end{code} -Expand abbreviations -~~~~~~~~~~~~~~~~~~~~ -Removes just the top level of any abbreviations. +%************************************************************************ +%* * +\subsection{Kinds} +%* * +%************************************************************************ \begin{code} -expandTy :: Type -> Type -- Restricted to Type due to Dict expansion +superKind :: GenKind flexi -- Box, the type of all kinds +superKind = TyConApp superKindCon [] -expandTy (FunTy t1 t2 u) = AppTy (AppTy (TyConTy mkFunTyCon u) t1) t2 -expandTy (SynTy _ _ t) = expandTy t -expandTy (DictTy clas ty u) - = case all_arg_tys of +boxedTypeKind, unboxedTypeKind, openTypeKind :: GenKind flexi +boxedTypeKind = TyConApp boxedKindCon [] +unboxedTypeKind = TyConApp unboxedKindCon [] +openTypeKind = TyConApp openKindCon [] - [arg_ty] -> expandTy arg_ty -- just the itself +mkArrowKind :: GenKind flexi -> GenKind flexi -> GenKind flexi +mkArrowKind = FunTy - -- The extra expandTy is to make sure that - -- the result isn't still a dict, which it might be - -- if the original guy was a dict with one superdict and - -- no methods! +mkArrowKinds :: [GenKind flexi] -> GenKind flexi -> GenKind flexi +mkArrowKinds arg_kinds result_kind = foldr FunTy result_kind arg_kinds +\end{code} - other -> ASSERT(not (null all_arg_tys)) - foldl AppTy (TyConTy (mkTupleTyCon (length all_arg_tys)) u) all_arg_tys +\begin{code} +hasMoreBoxityInfo :: GenKind flexi -> GenKind flexi -> Bool - -- A tuple of 'em - -- Note: length of all_arg_tys can be 0 if the class is - -- CCallable, CReturnable (and anything else - -- *really weird* that the user writes). - where - (tyvar, super_classes, ops) = classSig clas - super_dict_tys = map mk_super_ty super_classes - class_op_tys = map mk_op_ty ops - all_arg_tys = super_dict_tys ++ class_op_tys - mk_super_ty sc = DictTy sc ty usageOmega - mk_op_ty op = instantiateTy [(tyvar,ty)] (classOpLocalType op) - -expandTy ty = ty +(NoteTy _ k1) `hasMoreBoxityInfo` k2 = k1 `hasMoreBoxityInfo` k2 +k1 `hasMoreBoxityInfo` (NoteTy _ k2) = k1 `hasMoreBoxityInfo` k2 + +(TyConApp kc1 ts1) `hasMoreBoxityInfo` (TyConApp kc2 ts2) + = ASSERT( null ts1 && null ts2 ) + kc2 `matchesTyCon` kc1 -- NB the reversal of arguments + +kind1@(FunTy _ _) `hasMoreBoxityInfo` kind2@(FunTy _ _) + = ASSERT( kind1 == kind2 ) + True + -- The two kinds can be arrow kinds; for example when unifying + -- (m1 Int) and (m2 Int) we end up unifying m1 and m2, which should + -- have the same kind. + +-- Other cases are impossible \end{code} -Simple construction and analysis functions -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ + +%************************************************************************ +%* * +\subsection{Constructor-specific functions} +%* * +%************************************************************************ + + +--------------------------------------------------------------------- + TyVarTy + ~~~~~~~ \begin{code} -mkTyVarTy :: t -> GenType t u -mkTyVarTys :: [t] -> [GenType t y] +mkTyVarTy :: GenTyVar flexi -> GenType flexi mkTyVarTy = TyVarTy + +mkTyVarTys :: [GenTyVar flexi] -> [GenType flexi] mkTyVarTys = map mkTyVarTy -- a common use of mkTyVarTy -getTyVar :: String -> GenType t u -> t -getTyVar msg (TyVarTy tv) = tv -getTyVar msg (SynTy _ _ t) = getTyVar msg t -getTyVar msg other = panic ("getTyVar: " ++ msg) +getTyVar :: String -> GenType flexi -> GenTyVar flexi +getTyVar msg (TyVarTy tv) = tv +getTyVar msg (NoteTy _ t) = getTyVar msg t +getTyVar msg other = panic ("getTyVar: " ++ msg) -getTyVar_maybe :: GenType t u -> Maybe t -getTyVar_maybe (TyVarTy tv) = Just tv -getTyVar_maybe (SynTy _ _ t) = getTyVar_maybe t -getTyVar_maybe other = Nothing +getTyVar_maybe :: GenType flexi -> Maybe (GenTyVar flexi) +getTyVar_maybe (TyVarTy tv) = Just tv +getTyVar_maybe (NoteTy _ t) = getTyVar_maybe t +getTyVar_maybe other = Nothing -isTyVarTy :: GenType t u -> Bool +isTyVarTy :: GenType flexi -> Bool isTyVarTy (TyVarTy tv) = True -isTyVarTy (SynTy _ _ t) = isTyVarTy t -isTyVarTy other = False +isTyVarTy (NoteTy _ ty) = isTyVarTy ty +isTyVarTy other = False \end{code} -\begin{code} -mkAppTy = AppTy -mkAppTys :: GenType t u -> [GenType t u] -> GenType t u -mkAppTys t ts = foldl AppTy t ts +--------------------------------------------------------------------- + AppTy + ~~~~~ +We need to be pretty careful with AppTy to make sure we obey the +invariant that a TyConApp is always visibly so. mkAppTy maintains the +invariant: use it. -splitAppTy :: GenType t u -> (GenType t u, [GenType t u]) -splitAppTy t = go t [] +\begin{code} +mkAppTy orig_ty1 orig_ty2 = mk_app orig_ty1 where - go (AppTy t arg) ts = go t (arg:ts) - go (FunTy fun arg u) ts = (TyConTy mkFunTyCon u, fun:arg:ts) - go (SynTy _ _ t) ts = go t ts - go t ts = (t,ts) + mk_app (NoteTy _ ty1) = mk_app ty1 + mk_app (TyConApp tc tys) = mkTyConApp tc (tys ++ [orig_ty2]) + mk_app ty1 = AppTy orig_ty1 orig_ty2 + +mkAppTys :: GenType flexi -> [GenType flexi] -> GenType flexi +mkAppTys orig_ty1 [] = orig_ty1 + -- This check for an empty list of type arguments + -- avoids the needless of a type synonym constructor. + -- For example: mkAppTys Rational [] + -- returns to (Ratio Integer), which has needlessly lost + -- the Rational part. +mkAppTys orig_ty1 orig_tys2 = mk_app orig_ty1 + where + mk_app (NoteTy _ ty1) = mk_app ty1 + mk_app (TyConApp tc tys) = mkTyConApp tc (tys ++ orig_tys2) + mk_app ty1 = foldl AppTy orig_ty1 orig_tys2 + +splitAppTy_maybe :: GenType flexi -> Maybe (GenType flexi, GenType flexi) +splitAppTy_maybe (FunTy ty1 ty2) = Just (TyConApp funTyCon [ty1], ty2) +splitAppTy_maybe (AppTy ty1 ty2) = Just (ty1, ty2) +splitAppTy_maybe (NoteTy _ ty) = splitAppTy_maybe ty +splitAppTy_maybe (TyConApp tc []) = Nothing +splitAppTy_maybe (TyConApp tc tys) = split tys [] + where + split [ty2] acc = Just (TyConApp tc (reverse acc), ty2) + split (ty:tys) acc = split tys (ty:acc) + +splitAppTy_maybe other = Nothing + +splitAppTy :: GenType flexi -> (GenType flexi, GenType flexi) +splitAppTy ty = case splitAppTy_maybe ty of + Just pr -> pr + Nothing -> panic "splitAppTy" + +splitAppTys :: GenType flexi -> (GenType flexi, [GenType flexi]) +splitAppTys ty = split ty ty [] + where + split orig_ty (AppTy ty arg) args = split ty ty (arg:args) + split orig_ty (NoteTy _ ty) args = split orig_ty ty args + split orig_ty (FunTy ty1 ty2) args = ASSERT( null args ) + (TyConApp funTyCon [], [ty1,ty2]) + split orig_ty (TyConApp tc tc_args) args = (TyConApp tc [], tc_args ++ args) + split orig_ty ty args = (orig_ty, args) \end{code} + +--------------------------------------------------------------------- + FunTy + ~~~~~ + \begin{code} --- NB mkFunTy, mkFunTys puts in Omega usages, for now at least -mkFunTy arg res = FunTy arg res usageOmega - -mkFunTys :: [GenType t u] -> GenType t u -> GenType t u -mkFunTys ts t = foldr (\ f a -> FunTy f a usageOmega) t ts - - -- getFunTy_maybe and splitFunTy *must* have the general type given, which - -- means they *can't* do the DictTy jiggery-pokery that - -- *is* sometimes required. Hence we also have the ExpandingDicts variants - -- The relationship between these - -- two functions is like that between eqTy and eqSimpleTy. - -- ToDo: NUKE when we do dicts via newtype - -getFunTy_maybe :: GenType t u -> Maybe (GenType t u, GenType t u) -getFunTy_maybe (FunTy arg result _) = Just (arg,result) -getFunTy_maybe (AppTy (AppTy (TyConTy tycon _) arg) res) - | isFunTyCon tycon = Just (arg, res) -getFunTy_maybe (SynTy _ _ t) = getFunTy_maybe t -getFunTy_maybe other = Nothing - -getFunTyExpandingDicts_maybe :: Type -> Maybe (Type, Type) -getFunTyExpandingDicts_maybe (FunTy arg result _) = Just (arg,result) -getFunTyExpandingDicts_maybe - (AppTy (AppTy (TyConTy tycon _) arg) res) | isFunTyCon tycon = Just (arg, res) -getFunTyExpandingDicts_maybe (SynTy _ _ t) = getFunTyExpandingDicts_maybe t -getFunTyExpandingDicts_maybe ty@(DictTy _ _ _) = getFunTyExpandingDicts_maybe (expandTy ty) -getFunTyExpandingDicts_maybe other = Nothing - -splitFunTy :: GenType t u -> ([GenType t u], GenType t u) -splitFunTyExpandingDicts :: Type -> ([Type], Type) - -splitFunTy t = split_fun_ty getFunTy_maybe t -splitFunTyExpandingDicts t = split_fun_ty getFunTyExpandingDicts_maybe t - -split_fun_ty get t = go t [] +mkFunTy :: GenType flexi -> GenType flexi -> GenType flexi +mkFunTy arg res = FunTy arg res + +mkFunTys :: [GenType flexi] -> GenType flexi -> GenType flexi +mkFunTys tys ty = foldr FunTy ty tys + +splitFunTy_maybe :: GenType flexi -> Maybe (GenType flexi, GenType flexi) +splitFunTy_maybe (FunTy arg res) = Just (arg, res) +splitFunTy_maybe (NoteTy _ ty) = splitFunTy_maybe ty +splitFunTy_maybe other = Nothing + + +splitFunTys :: GenType flexi -> ([GenType flexi], GenType flexi) +splitFunTys ty = split [] ty ty where - go t ts = case (get t) of - Just (arg,res) -> go res (arg:ts) - Nothing -> (reverse ts, t) + split args orig_ty (FunTy arg res) = split (arg:args) res res + split args orig_ty (NoteTy _ ty) = split args orig_ty ty + split args orig_ty ty = (reverse args, orig_ty) + +funResultTy :: GenType flexi -> GenType flexi +funResultTy (FunTy arg res) = res +funResultTy (NoteTy _ ty) = funResultTy ty +funResultTy ty = ty \end{code} + + +--------------------------------------------------------------------- + TyConApp + ~~~~~~~~ + \begin{code} --- NB applyTyCon puts in usageOmega, for now at least -mkTyConTy tycon - = ASSERT(not (isSynTyCon tycon)) - TyConTy tycon usageOmega +mkTyConApp :: TyCon -> [GenType flexi] -> GenType flexi +mkTyConApp tycon tys + | isFunTyCon tycon && length tys == 2 + = case tys of + (ty1:ty2:_) -> FunTy ty1 ty2 -applyTyCon :: TyCon -> [GenType t u] -> GenType t u -applyTyCon tycon tys - = ASSERT (not (isSynTyCon tycon)) - foldl AppTy (TyConTy tycon usageOmega) tys + | otherwise + = ASSERT(not (isSynTyCon tycon)) + TyConApp tycon tys + +mkTyConTy :: TyCon -> GenType flexi +mkTyConTy tycon = ASSERT( not (isSynTyCon tycon) ) + TyConApp tycon [] + +-- splitTyConApp "looks through" synonyms, because they don't +-- mean a distinct type, but all other type-constructor applications +-- including functions are returned as Just .. + +splitTyConApp_maybe :: GenType flexi -> Maybe (TyCon, [GenType flexi]) +splitTyConApp_maybe (TyConApp tc tys) = Just (tc, tys) +splitTyConApp_maybe (FunTy arg res) = Just (funTyCon, [arg,res]) +splitTyConApp_maybe (NoteTy _ ty) = splitTyConApp_maybe ty +splitTyConApp_maybe other = Nothing + +-- splitAlgTyConApp_maybe looks for +-- *saturated* applications of *algebraic* data types +-- "Algebraic" => newtype, data type, or dictionary (not function types) +-- We return the constructors too. + +splitAlgTyConApp_maybe :: GenType flexi -> Maybe (TyCon, [GenType flexi], [DataCon]) +splitAlgTyConApp_maybe (TyConApp tc tys) + | isAlgTyCon tc && + tyConArity tc == length tys = Just (tc, tys, tyConDataCons tc) +splitAlgTyConApp_maybe (NoteTy _ ty) = splitAlgTyConApp_maybe ty +splitAlgTyConApp_maybe other = Nothing + +splitAlgTyConApp :: GenType flexi -> (TyCon, [GenType flexi], [DataCon]) + -- Here the "algebraic" property is an *assertion* +splitAlgTyConApp (TyConApp tc tys) = ASSERT( isAlgTyCon tc && tyConArity tc == length tys ) + (tc, tys, tyConDataCons tc) +splitAlgTyConApp (NoteTy _ ty) = splitAlgTyConApp ty +\end{code} -getTyCon_maybe :: GenType t u -> Maybe TyCon ---getTyConExpandingDicts_maybe :: Type -> Maybe TyCon +"Dictionary" types are just ordinary data types, but you can +tell from the type constructor whether it's a dictionary or not. -getTyCon_maybe (TyConTy tycon _) = Just tycon -getTyCon_maybe (SynTy _ _ t) = getTyCon_maybe t -getTyCon_maybe other_ty = Nothing +\begin{code} +mkDictTy :: Class -> [GenType flexi] -> GenType flexi +mkDictTy clas tys = TyConApp (classTyCon clas) tys ---getTyConExpandingDicts_maybe (TyConTy tycon _) = Just tycon ---getTyConExpandingDicts_maybe (SynTy _ _ t) = getTyConExpandingDicts_maybe t ---getTyConExpandingDicts_maybe ty@(DictTy _ _ _) = getTyConExpandingDicts_maybe (expandTy ty) ---getTyConExpandingDicts_maybe other_ty = Nothing +splitDictTy_maybe :: GenType flexi -> Maybe (Class, [GenType flexi]) +splitDictTy_maybe (TyConApp tc tys) + | maybeToBool maybe_class + && tyConArity tc == length tys = Just (clas, tys) + where + maybe_class = tyConClass_maybe tc + Just clas = maybe_class + +splitDictTy_maybe (NoteTy _ ty) = splitDictTy_maybe ty +splitDictTy_maybe other = Nothing + +isDictTy :: GenType flexi -> Bool + -- This version is slightly more efficient than (maybeToBool . splitDictTy) +isDictTy (TyConApp tc tys) + | maybeToBool (tyConClass_maybe tc) + && tyConArity tc == length tys + = True +isDictTy (NoteTy _ ty) = isDictTy ty +isDictTy other = False \end{code} + +--------------------------------------------------------------------- + SynTy + ~~~~~ + \begin{code} mkSynTy syn_tycon tys = ASSERT(isSynTyCon syn_tycon) - SynTy syn_tycon tys (instantiateTauTy (zipEqual "mkSynTy" tyvars tys) body) + NoteTy (SynNote (TyConApp syn_tycon tys)) + (substFlexiTy (zipVarEnv tyvars tys) body) + -- The "flexi" is needed so we can get a TcType from a synonym where (tyvars, body) = getSynTyConDefn syn_tycon -\end{code} -Tau stuff -~~~~~~~~~ -\begin{code} -isTauTy :: GenType t u -> Bool -isTauTy (TyVarTy v) = True -isTauTy (TyConTy _ _) = True -isTauTy (AppTy a b) = isTauTy a && isTauTy b -isTauTy (FunTy a b _) = isTauTy a && isTauTy b -isTauTy (SynTy _ _ ty) = isTauTy ty -isTauTy other = False +isSynTy (NoteTy (SynNote _) _) = True +isSynTy other = False \end{code} -Rho stuff -~~~~~~~~~ -NB mkRhoTy and mkDictTy put in usageOmega, for now at least +Notes on type synonyms +~~~~~~~~~~~~~~~~~~~~~~ +The various "split" functions (splitFunTy, splitRhoTy, splitForAllTy) try +to return type synonyms whereever possible. Thus -\begin{code} -mkDictTy :: Class -> GenType t u -> GenType t u -mkDictTy clas ty = DictTy clas ty usageOmega + type Foo a = a -> a + +we want + splitFunTys (a -> Foo a) = ([a], Foo a) +not ([a], a -> a) + +The reason is that we then get better (shorter) type signatures in +interfaces. Notably this plays a role in tcTySigs in TcBinds.lhs. -mkRhoTy :: [(Class, GenType t u)] -> GenType t u -> GenType t u -mkRhoTy theta ty = - foldr (\(c,t) r -> FunTy (DictTy c t usageOmega) r usageOmega) ty theta -splitRhoTy :: GenType t u -> ([(Class,GenType t u)], GenType t u) -splitRhoTy t = - go t [] - where - go (FunTy (DictTy c t _) r _) ts = go r ((c,t):ts) - go (AppTy (AppTy (TyConTy tycon _) (DictTy c t _)) r) ts - | isFunTyCon tycon - = go r ((c,t):ts) - go (SynTy _ _ t) ts = go t ts - go t ts = (reverse ts, t) - - -mkTheta :: [Type] -> ThetaType - -- recover a ThetaType from the types of some dictionaries -mkTheta dict_tys - = map cvt dict_tys - where - cvt (DictTy clas ty _) = (clas, ty) - cvt other = pprPanic "mkTheta:" (pprType PprDebug other) -\end{code} -Forall stuff -~~~~~~~~~~~~ +--------------------------------------------------------------------- + ForAllTy + ~~~~~~~~ + \begin{code} mkForAllTy = ForAllTy -mkForAllTys :: [t] -> GenType t u -> GenType t u +mkForAllTys :: [GenTyVar flexi] -> GenType flexi -> GenType flexi mkForAllTys tyvars ty = foldr ForAllTy ty tyvars -getForAllTy_maybe :: GenType t u -> Maybe (t,GenType t u) -getForAllTy_maybe (SynTy _ _ t) = getForAllTy_maybe t -getForAllTy_maybe (ForAllTy tyvar t) = Just(tyvar,t) -getForAllTy_maybe _ = Nothing - -splitForAllTy :: GenType t u-> ([t], GenType t u) -splitForAllTy t = go t [] - where - go (ForAllTy tv t) tvs = go t (tv:tvs) - go (SynTy _ _ t) tvs = go t tvs - go t tvs = (reverse tvs, t) +splitForAllTy_maybe :: GenType flexi -> Maybe (GenTyVar flexi, GenType flexi) +splitForAllTy_maybe (NoteTy _ ty) = splitForAllTy_maybe ty +splitForAllTy_maybe (ForAllTy tyvar ty) = Just(tyvar, ty) +splitForAllTy_maybe _ = Nothing + +isForAllTy :: GenType flexi -> Bool +isForAllTy (NoteTy _ ty) = isForAllTy ty +isForAllTy (ForAllTy tyvar ty) = True +isForAllTy _ = False + +splitForAllTys :: GenType flexi -> ([GenTyVar flexi], GenType flexi) +splitForAllTys ty = split ty ty [] + where + split orig_ty (ForAllTy tv ty) tvs = split ty ty (tv:tvs) + split orig_ty (NoteTy _ ty) tvs = split orig_ty ty tvs + split orig_ty t tvs = (reverse tvs, orig_ty) \end{code} -\begin{code} -mkForAllUsageTy :: u -> [u] -> GenType t u -> GenType t u -mkForAllUsageTy = ForAllUsageTy +@mkPiType@ makes a (->) type or a forall type, depending on whether +it is given a type variable or a term variable. -getForAllUsageTy :: GenType t u -> Maybe (u,[u],GenType t u) -getForAllUsageTy (ForAllUsageTy uvar bounds t) = Just(uvar,bounds,t) -getForAllUsageTy (SynTy _ _ t) = getForAllUsageTy t -getForAllUsageTy _ = Nothing +\begin{code} +mkPiType :: IdOrTyVar -> Type -> Type -- The more polymorphic version doesn't work... +mkPiType v ty | isId v = mkFunTy (idType v) ty + | otherwise = ForAllTy v ty \end{code} -Applied tycons (includes FunTyCons) -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -maybeAppTyCon - :: GenType tyvar uvar - -> Maybe (TyCon, -- the type constructor - [GenType tyvar uvar]) -- types to which it is applied - -maybeAppTyCon ty - = case (getTyCon_maybe app_ty) of - Nothing -> Nothing - Just tycon -> Just (tycon, arg_tys) - where - (app_ty, arg_tys) = splitAppTy ty +applyTy :: GenType flexi -> GenType flexi -> GenType flexi +applyTy (NoteTy _ fun) arg = applyTy fun arg +applyTy (ForAllTy tv ty) arg = substTy (mkVarEnv [(tv,arg)]) ty +applyTy other arg = panic "applyTy" + +applyTys :: GenType flexi -> [GenType flexi] -> GenType flexi +applyTys fun_ty arg_tys + = go [] fun_ty arg_tys + where + go env ty [] = substTy (mkVarEnv env) ty + go env (NoteTy _ fun) args = go env fun args + go env (ForAllTy tv ty) (arg:args) = go ((tv,arg):env) ty args + go env other args = panic "applyTys" +\end{code} + + +%************************************************************************ +%* * +\subsection{Stuff to do with the source-language types} +%* * +%************************************************************************ +\begin{code} +type RhoType = Type +type TauType = Type +type ThetaType = [(Class, [Type])] +type SigmaType = Type +\end{code} -getAppTyCon - :: GenType tyvar uvar - -> (TyCon, -- the type constructor - [GenType tyvar uvar]) -- types to which it is applied +@isTauTy@ tests for nested for-alls. -getAppTyCon ty - = case maybeAppTyCon ty of - Just stuff -> stuff -#ifdef DEBUG - Nothing -> panic "Type.getAppTyCon" -- (ppr PprShowAll ty) -#endif +\begin{code} +isTauTy :: GenType flexi -> Bool +isTauTy (TyVarTy v) = True +isTauTy (TyConApp _ tys) = all isTauTy tys +isTauTy (AppTy a b) = isTauTy a && isTauTy b +isTauTy (FunTy a b) = isTauTy a && isTauTy b +isTauTy (NoteTy _ ty) = isTauTy ty +isTauTy other = False \end{code} -Applied data tycons (give back constrs) -~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -maybeAppDataTyCon - :: GenType tyvar uvar - -> Maybe (TyCon, -- the type constructor - [GenType tyvar uvar], -- types to which it is applied - [Id]) -- its family of data-constructors -maybeAppDataTyConExpandingDicts, maybeAppSpecDataTyConExpandingDicts - :: Type -> Maybe (TyCon, [Type], [Id]) - -maybeAppDataTyCon ty = maybe_app_data_tycon (\x->x) ty -maybeAppDataTyConExpandingDicts ty = maybe_app_data_tycon expandTy ty -maybeAppSpecDataTyConExpandingDicts ty = maybe_app_data_tycon expandTy ty - - -maybe_app_data_tycon expand ty - = case (getTyCon_maybe app_ty) of - Just tycon | isDataTyCon tycon && - tyConArity tycon == length arg_tys - -- Must be saturated for ty to be a data type - -> Just (tycon, arg_tys, tyConDataCons tycon) - - other -> Nothing - where - (app_ty, arg_tys) = splitAppTy (expand ty) - -getAppDataTyCon, getAppSpecDataTyCon - :: GenType tyvar uvar - -> (TyCon, -- the type constructor - [GenType tyvar uvar], -- types to which it is applied - [Id]) -- its family of data-constructors -getAppDataTyConExpandingDicts, getAppSpecDataTyConExpandingDicts - :: Type -> (TyCon, [Type], [Id]) - -getAppDataTyCon ty = get_app_data_tycon maybeAppDataTyCon ty -getAppDataTyConExpandingDicts ty = get_app_data_tycon maybeAppDataTyConExpandingDicts ty - --- these should work like the UniTyFuns.getUniDataSpecTyCon* things of old (ToDo) -getAppSpecDataTyCon = getAppDataTyCon -getAppSpecDataTyConExpandingDicts = getAppDataTyConExpandingDicts - -get_app_data_tycon maybe ty - = case maybe ty of - Just stuff -> stuff -#ifdef DEBUG - Nothing -> panic "Type.getAppDataTyCon" -- (pprGenType PprShowAll ty) -#endif - - -maybeBoxedPrimType :: Type -> Maybe (Id, Type) - -maybeBoxedPrimType ty - = case (maybeAppDataTyCon ty) of -- Data type, - Just (tycon, tys_applied, [data_con]) -- with exactly one constructor - -> case (dataConArgTys data_con tys_applied) of - [data_con_arg_ty] -- Applied to exactly one type, - | isPrimType data_con_arg_ty -- which is primitive - -> Just (data_con, data_con_arg_ty) - other_cases -> Nothing - other_cases -> Nothing +mkRhoTy :: [(Class, [GenType flexi])] -> GenType flexi -> GenType flexi +mkRhoTy theta ty = foldr (\(c,t) r -> FunTy (mkDictTy c t) r) ty theta + +splitRhoTy :: GenType flexi -> ([(Class, [GenType flexi])], GenType flexi) +splitRhoTy ty = split ty ty [] + where + split orig_ty (FunTy arg res) ts = case splitDictTy_maybe arg of + Just pair -> split res res (pair:ts) + Nothing -> (reverse ts, orig_ty) + split orig_ty (NoteTy _ ty) ts = split orig_ty ty ts + split orig_ty ty ts = (reverse ts, orig_ty) \end{code} + + \begin{code} -splitSigmaTy :: GenType t u -> ([t], [(Class,GenType t u)], GenType t u) +mkSigmaTy tyvars theta tau = mkForAllTys tyvars (mkRhoTy theta tau) + +splitSigmaTy :: GenType flexi -> ([GenTyVar flexi], [(Class, [GenType flexi])], GenType flexi) splitSigmaTy ty = (tyvars, theta, tau) where - (tyvars,rho) = splitForAllTy ty + (tyvars,rho) = splitForAllTys ty (theta,tau) = splitRhoTy rho - -mkSigmaTy tyvars theta tau = mkForAllTys tyvars (mkRhoTy theta tau) \end{code} -Finding the kind of a type -~~~~~~~~~~~~~~~~~~~~~~~~~~ +%************************************************************************ +%* * +\subsection{Kinds and free variables} +%* * +%************************************************************************ + +--------------------------------------------------------------------- + Finding the kind of a type + ~~~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -typeKind :: GenType (GenTyVar any) u -> Kind +-- typeKind is only ever used on Types, never Kinds +-- If it were used on Kinds, the typeKind of FunTy would not be boxedTypeKind; +-- yet at the type level functions are boxed even if neither argument nor +-- result are boxed. This seems pretty fishy to me. + +typeKind :: GenType flexi -> Kind + typeKind (TyVarTy tyvar) = tyVarKind tyvar -typeKind (TyConTy tycon usage) = tyConKind tycon -typeKind (SynTy _ _ ty) = typeKind ty -typeKind (FunTy fun arg _) = mkBoxedTypeKind -typeKind (DictTy clas arg _) = mkBoxedTypeKind -typeKind (AppTy fun arg) = resultKind (typeKind fun) -typeKind (ForAllTy _ _) = mkBoxedTypeKind -typeKind (ForAllUsageTy _ _ _) = mkBoxedTypeKind +typeKind (TyConApp tycon tys) = foldr (\_ k -> funResultTy k) (tyConKind tycon) tys +typeKind (NoteTy _ ty) = typeKind ty +typeKind (FunTy fun arg) = boxedTypeKind +typeKind (AppTy fun arg) = funResultTy (typeKind fun) +typeKind (ForAllTy _ _) = boxedTypeKind \end{code} -Free variables of a type -~~~~~~~~~~~~~~~~~~~~~~~~ +--------------------------------------------------------------------- + Free variables of a type + ~~~~~~~~~~~~~~~~~~~~~~~~ \begin{code} -tyVarsOfType :: GenType (GenTyVar flexi) uvar -> GenTyVarSet flexi - -tyVarsOfType (TyVarTy tv) = unitTyVarSet tv -tyVarsOfType (TyConTy tycon usage) = emptyTyVarSet -tyVarsOfType (SynTy _ tys ty) = tyVarsOfTypes tys -tyVarsOfType (FunTy arg res _) = tyVarsOfType arg `unionTyVarSets` tyVarsOfType res -tyVarsOfType (AppTy fun arg) = tyVarsOfType fun `unionTyVarSets` tyVarsOfType arg -tyVarsOfType (DictTy clas ty _) = tyVarsOfType ty -tyVarsOfType (ForAllTy tyvar ty) = tyVarsOfType ty `minusTyVarSet` unitTyVarSet tyvar -tyVarsOfType (ForAllUsageTy _ _ ty) = tyVarsOfType ty - -tyVarsOfTypes :: [GenType (GenTyVar flexi) uvar] -> GenTyVarSet flexi -tyVarsOfTypes tys = foldr (unionTyVarSets.tyVarsOfType) emptyTyVarSet tys +tyVarsOfType :: GenType flexi -> GenTyVarSet flexi + +tyVarsOfType (TyVarTy tv) = unitVarSet tv +tyVarsOfType (TyConApp tycon tys) = tyVarsOfTypes tys +tyVarsOfType (NoteTy (FTVNote tvs) ty2) = tvs +tyVarsOfType (NoteTy (SynNote ty1) ty2) = tyVarsOfType ty1 +tyVarsOfType (FunTy arg res) = tyVarsOfType arg `unionVarSet` tyVarsOfType res +tyVarsOfType (AppTy fun arg) = tyVarsOfType fun `unionVarSet` tyVarsOfType arg +tyVarsOfType (ForAllTy tyvar ty) = tyVarsOfType ty `minusVarSet` unitVarSet tyvar + +tyVarsOfTypes :: [GenType flexi] -> GenTyVarSet flexi +tyVarsOfTypes tys = foldr (unionVarSet.tyVarsOfType) emptyVarSet tys + +-- Add a Note with the free tyvars to the top of the type +addFreeTyVars :: GenType flexi -> GenType flexi +addFreeTyVars ty@(NoteTy (FTVNote _) _) = ty +addFreeTyVars ty = NoteTy (FTVNote (tyVarsOfType ty)) ty + +-- Find the free names of a type, including the type constructors and classes it mentions +namesOfType :: GenType flexi -> NameSet +namesOfType (TyVarTy tv) = unitNameSet (getName tv) +namesOfType (TyConApp tycon tys) = unitNameSet (getName tycon) `unionNameSets` + namesOfTypes tys +namesOfType (NoteTy (SynNote ty1) ty2) = namesOfType ty1 +namesOfType (NoteTy other_note ty2) = namesOfType ty2 +namesOfType (FunTy arg res) = namesOfType arg `unionNameSets` namesOfType res +namesOfType (AppTy fun arg) = namesOfType fun `unionNameSets` namesOfType arg +namesOfType (ForAllTy tyvar ty) = namesOfType ty `minusNameSet` unitNameSet (getName tyvar) + +namesOfTypes tys = foldr (unionNameSets . namesOfType) emptyNameSet tys \end{code} -Instantiating a type -~~~~~~~~~~~~~~~~~~~~ -\begin{code} -applyTy :: GenType (GenTyVar flexi) uvar - -> GenType (GenTyVar flexi) uvar - -> GenType (GenTyVar flexi) uvar +%************************************************************************ +%* * +\subsection{Instantiating a type} +%* * +%************************************************************************ -applyTy (SynTy _ _ fun) arg = applyTy fun arg -applyTy (ForAllTy tv ty) arg = instantiateTy [(tv,arg)] ty -applyTy other arg = panic "applyTy" -\end{code} +@substTy@ applies a substitution to a type. It deals correctly with name capture. \begin{code} -instantiateTy :: [(GenTyVar flexi, GenType (GenTyVar flexi) uvar)] - -> GenType (GenTyVar flexi) uvar - -> GenType (GenTyVar flexi) uvar - -instantiateTauTy :: Eq tv => - [(tv, GenType tv' u)] - -> GenType tv u - -> GenType tv' u - -applyTypeEnvToTy :: TyVarEnv Type -> SigmaType -> SigmaType +substTy :: GenTyVarSubst flexi -> GenType flexi -> GenType flexi +substTy tenv ty = subst_ty tenv tset ty + where + tset = foldVarEnv (unionVarSet . tyVarsOfType) emptyVarSet tenv + -- If ty doesn't have any for-alls, then this thunk + -- will never be evaluated +\end{code} --- instantiateTauTy works only (a) on types with no ForAlls, --- and when (b) all the type variables are being instantiated --- In return it is more polymorphic than instantiateTy +@fullSubstTy@ is like @substTy@ except that it needs to be given a set +of in-scope type variables. In exchange it's a bit more efficient, at least +if you happen to have that set lying around. -instant_help ty lookup_tv deflt_tv choose_tycon - if_usage if_forall bound_forall_tv_BAD deflt_forall_tv - = go ty - where - go (TyVarTy tv) = case (lookup_tv tv) of - Nothing -> deflt_tv tv - Just ty -> ty - go ty@(TyConTy tycon usage) = choose_tycon ty tycon usage - go (SynTy tycon tys ty) = SynTy tycon (map go tys) (go ty) - go (FunTy arg res usage) = FunTy (go arg) (go res) usage - go (AppTy fun arg) = AppTy (go fun) (go arg) - go (DictTy clas ty usage) = DictTy clas (go ty) usage - go (ForAllUsageTy uvar bds ty) = if_usage $ - ForAllUsageTy uvar bds (go ty) - go (ForAllTy tv ty) = if_forall $ - (if (bound_forall_tv_BAD && maybeToBool (lookup_tv tv)) then - trace "instantiateTy: unexpected forall hit" - else - \x->x) ForAllTy (deflt_forall_tv tv) (go ty) - -instantiateTy tenv ty - = instant_help ty lookup_tv deflt_tv choose_tycon - if_usage if_forall bound_forall_tv_BAD deflt_forall_tv - where - lookup_tv tv = case [ty | (tv',ty) <- tenv, tv == tv'] of - [] -> Nothing - [ty] -> Just ty - _ -> panic "instantiateTy:lookup_tv" - - deflt_tv tv = TyVarTy tv - choose_tycon ty _ _ = ty - if_usage ty = ty - if_forall ty = ty - bound_forall_tv_BAD = True - deflt_forall_tv tv = tv - -instantiateTauTy tenv ty - = instant_help ty lookup_tv deflt_tv choose_tycon - if_usage if_forall bound_forall_tv_BAD deflt_forall_tv - where - lookup_tv tv = case [ty | (tv',ty) <- tenv, tv == tv'] of - [] -> Nothing - [ty] -> Just ty - _ -> panic "instantiateTauTy:lookup_tv" - - deflt_tv tv = panic "instantiateTauTy" - choose_tycon _ tycon usage = TyConTy tycon usage - if_usage ty = panic "instantiateTauTy:ForAllUsageTy" - if_forall ty = panic "instantiateTauTy:ForAllTy" - bound_forall_tv_BAD = panic "instantiateTauTy:bound_forall_tv" - deflt_forall_tv tv = panic "instantiateTauTy:deflt_forall_tv" - -applyTypeEnvToTy tenv ty - = instant_help ty lookup_tv deflt_tv choose_tycon - if_usage if_forall bound_forall_tv_BAD deflt_forall_tv - where - lookup_tv = lookupTyVarEnv tenv - deflt_tv tv = TyVarTy tv - choose_tycon ty _ _ = ty - if_usage ty = ty - if_forall ty = ty - bound_forall_tv_BAD = False -- ToDo: probably should be True (i.e., no shadowing) - deflt_forall_tv tv = case (lookup_tv tv) of - Nothing -> tv - Just (TyVarTy tv2) -> tv2 - _ -> panic "applyTypeEnvToTy" -{- -instantiateTy tenv ty - = go ty - where - go (TyVarTy tv) = case [ty | (tv',ty) <- tenv, tv==tv'] of - [] -> TyVarTy tv - (ty:_) -> ty - go ty@(TyConTy tycon usage) = ty - go (SynTy tycon tys ty) = SynTy tycon (map go tys) (go ty) - go (FunTy arg res usage) = FunTy (go arg) (go res) usage - go (AppTy fun arg) = AppTy (go fun) (go arg) - go (DictTy clas ty usage) = DictTy clas (go ty) usage - go (ForAllTy tv ty) = ASSERT(null tv_bound) - ForAllTy tv (go ty) - where - tv_bound = [() | (tv',_) <- tenv, tv==tv'] - - go (ForAllUsageTy uvar bds ty) = ForAllUsageTy uvar bds (go ty) - -instantiateTauTy tenv ty - = go ty +\begin{code} +fullSubstTy :: GenTyVarSubst flexi -- Substitution to apply + -> GenTyVarSet flexi -- Superset of the free tyvars of + -- the range of the tyvar env + -> GenType flexi -> GenType flexi +-- ASSUMPTION: The substitution is idempotent. +-- Equivalently: No tyvar is both in scope, and in the domain of the substitution. +fullSubstTy tenv tset ty | isEmptyVarEnv tenv = ty + | otherwise = subst_ty tenv tset ty + +-- subst_ty does the business +subst_ty tenv tset ty + = go ty where - go (TyVarTy tv) = case [ty | (tv',ty) <- tenv, tv==tv'] of - (ty:_) -> ty - [] -> panic "instantiateTauTy" - go (TyConTy tycon usage) = TyConTy tycon usage - go (SynTy tycon tys ty) = SynTy tycon (map go tys) (go ty) - go (FunTy arg res usage) = FunTy (go arg) (go res) usage - go (AppTy fun arg) = AppTy (go fun) (go arg) - go (DictTy clas ty usage) = DictTy clas (go ty) usage - -applyTypeEnvToTy tenv ty - = let - result = mapOverTyVars v_fn ty - in --- pprTrace "applyTypeEnv:" (ppAboves [pprType PprDebug ty, pprType PprDebug result, ppAboves [ppCat [pprUnique u, pprType PprDebug t] | (u,t) <- ufmToList tenv]]) $ - result + go (TyConApp tc tys) = TyConApp tc (map go tys) + go (NoteTy (SynNote ty1) ty2) = NoteTy (SynNote (go ty1)) (go ty2) + go (NoteTy (FTVNote _) ty2) = go ty2 -- Discard the free tyvar note + go (FunTy arg res) = FunTy (go arg) (go res) + go (AppTy fun arg) = mkAppTy (go fun) (go arg) + go ty@(TyVarTy tv) = case (lookupVarEnv tenv tv) of + Nothing -> ty + Just ty' -> ty' + go (ForAllTy tv ty) = case substTyVar tenv tset tv of + (tenv', tset', tv') -> ForAllTy tv' (subst_ty tenv' tset' ty) + +substTyVar :: GenTyVarSubst flexi -> GenTyVarSet flexi -> GenTyVar flexi + -> (GenTyVarSubst flexi, GenTyVarSet flexi, GenTyVar flexi) + +substTyVar tenv tset tv + | not (tv `elemVarSet` tset) -- No need to clone + -- But must delete from substitution + = (tenv `delVarEnv` tv, tset `extendVarSet` tv, tv) + + | otherwise -- The forall's variable is in scope so + -- we'd better rename it away from the in-scope variables + -- Extending the substitution to do this renaming also + -- has the (correct) effect of discarding any existing + -- substitution for that variable + = (extendVarEnv tenv tv (TyVarTy tv'), tset `extendVarSet` tv', tv') where - v_fn v = case (lookupTyVarEnv tenv v) of - Just ty -> ty - Nothing -> TyVarTy v + tv' = uniqAway tset tv \end{code} -@mapOverTyVars@ is a local function which actually does the work. It -does no cloning or other checks for shadowing, so be careful when -calling this on types with Foralls in them. -\begin{code} -mapOverTyVars :: (TyVar -> Type) -> Type -> Type - -mapOverTyVars v_fn ty - = let - mapper = mapOverTyVars v_fn - in - case ty of - TyVarTy v -> v_fn v - SynTy c as e -> SynTy c (map mapper as) (mapper e) - FunTy a r u -> FunTy (mapper a) (mapper r) u - AppTy f a -> AppTy (mapper f) (mapper a) - DictTy c t u -> DictTy c (mapper t) u - ForAllTy v t -> case (v_fn v) of - TyVarTy v2 -> ForAllTy v2 (mapper t) - _ -> panic "mapOverTyVars" - tc@(TyConTy _ _) -> tc --} -\end{code} +@substFlexiTy@ applies a substitution to a (GenType flexi1) returning +a (GenType flexi2). Note that we convert from one flexi status to another. -\begin{code} -instantiateUsage - :: Ord3 u => [(u, GenType t u')] -> GenType t u -> GenType t u' - -instantiateUsage = panic "instantiateUsage: not implemented" -\end{code} +Two assumptions, for (substFlexiTy env ty) + (a) the substitution, env, must cover all free tyvars of the type, ty + (b) the free vars of the range of the substitution must be + different than any of the forall'd variables in the type, ty -At present there are no unboxed non-primitive types, so -isUnboxedType is the same as isPrimType. +The latter assumption is reasonable because, after all, ty has a different +type to the range of the substitution. \begin{code} -isPrimType, isUnboxedType :: GenType tyvar uvar -> Bool +substFlexiTy :: GenTyVarSubst flexi2 -> GenType flexi1 -> GenType flexi2 +substFlexiTy env ty = go ty + where + go (TyVarTy tv) = case lookupVarEnv env tv of + Just ty -> ty + Nothing -> pprPanic "substFlexiTy" (ppr tv) + go (TyConApp tc tys) = TyConApp tc (map go tys) + go (NoteTy (SynNote ty1) ty2) = NoteTy (SynNote (go ty1)) (go ty2) + go (NoteTy (FTVNote _) ty2) = go ty2 -- Discard free tyvar note + go (FunTy arg res) = FunTy (go arg) (go res) + go (AppTy fun arg) = mkAppTy (go fun) (go arg) + go (ForAllTy tv ty) = ForAllTy tv' (substFlexiTy env' ty) + where + tv' = removeTyVarFlexi tv + env' = extendVarEnv env tv (TyVarTy tv') + +substFlexiTheta :: GenTyVarSubst flexi2 -> [(Class, [GenType flexi1])] + -> [(Class, [GenType flexi2])] +substFlexiTheta env theta = [(clas, map (substFlexiTy env) tys) | (clas,tys) <- theta] +\end{code} -isPrimType (AppTy ty _) = isPrimType ty -isPrimType (SynTy _ _ ty) = isPrimType ty -isPrimType (TyConTy tycon _) = isPrimTyCon tycon -isPrimType _ = False -isUnboxedType = isPrimType -\end{code} +%************************************************************************ +%* * +\subsection{Boxedness and liftedness} +%* * +%************************************************************************ -This is *not* right: it is a placeholder (ToDo 96/03 WDP): \begin{code} -typePrimRep :: GenType tyvar uvar -> PrimRep - -typePrimRep (SynTy _ _ ty) = typePrimRep ty -typePrimRep (TyConTy tc _) = if isPrimTyCon tc then panic "typePrimRep:PrimTyCon" else PtrRep -typePrimRep (AppTy ty _) = typePrimRep ty -typePrimRep _ = PtrRep -- the "default" +isUnboxedType :: GenType flexi -> Bool +isUnboxedType ty = not (isFollowableRep (typePrimRep ty)) + +isUnLiftedType :: GenType flexi -> Bool +isUnLiftedType ty = case splitTyConApp_maybe ty of + Just (tc, ty_args) -> isUnLiftedTyCon tc + other -> False + +isUnboxedTupleType :: GenType flexi -> Bool +isUnboxedTupleType ty = case splitTyConApp_maybe ty of + Just (tc, ty_args) -> isUnboxedTupleTyCon tc + other -> False + +isAlgType :: GenType flexi -> Bool +isAlgType ty = case splitTyConApp_maybe ty of + Just (tc, ty_args) -> isAlgTyCon tc + other -> False + +typePrimRep :: GenType flexi -> PrimRep +typePrimRep ty = case splitTyConApp_maybe ty of + Just (tc, ty_args) -> tyConPrimRep tc + other -> PtrRep \end{code} %************************************************************************ %* * -\subsection{Matching on types} +\subsection{Equality on types} %* * %************************************************************************ -Matching is a {\em unidirectional} process, matching a type against a -template (which is just a type with type variables in it). The -matcher assumes that there are no repeated type variables in the -template, so that it simply returns a mapping of type variables to -types. It also fails on nested foralls. - -@matchTys@ matches corresponding elements of a list of templates and -types. +For the moment at least, type comparisons don't work if +there are embedded for-alls. \begin{code} -matchTy :: GenType t1 u1 -- Template - -> GenType t2 u2 -- Proposed instance of template - -> Maybe [(t1,GenType t2 u2)] -- Matching substitution +instance Eq (GenType flexi) where + ty1 == ty2 = case ty1 `cmpTy` ty2 of { EQ -> True; other -> False } -matchTys :: [GenType t1 u1] -- Templates - -> [GenType t2 u2] -- Proposed instance of template - -> Maybe [(t1,GenType t2 u2)] -- Matching substitution +instance Ord (GenType flexi) where + compare ty1 ty2 = cmpTy ty1 ty2 -matchTy ty1 ty2 = match [] [] ty1 ty2 -matchTys tys1 tys2 = match' [] (zipEqual "matchTys" tys1 tys2) +cmpTy :: GenType flexi -> GenType flexi -> Ordering +cmpTy ty1 ty2 + = cmp emptyVarEnv ty1 ty2 + where + -- The "env" maps type variables in ty1 to type variables in ty2 + -- So when comparing for-alls.. (forall tv1 . t1) (forall tv2 . t2) + -- we in effect substitute tv2 for tv1 in t1 before continuing + lookup env tv1 = case lookupVarEnv env tv1 of + Just tv2 -> tv2 + Nothing -> tv1 + + -- Get rid of NoteTy + cmp env (NoteTy _ ty1) ty2 = cmp env ty1 ty2 + cmp env ty1 (NoteTy _ ty2) = cmp env ty1 ty2 + + -- Deal with equal constructors + cmp env (TyVarTy tv1) (TyVarTy tv2) = lookup env tv1 `compare` tv2 + cmp env (AppTy f1 a1) (AppTy f2 a2) = cmp env f1 f2 `thenCmp` cmp env a1 a2 + cmp env (FunTy f1 a1) (FunTy f2 a2) = cmp env f1 f2 `thenCmp` cmp env a1 a2 + cmp env (TyConApp tc1 tys1) (TyConApp tc2 tys2) = (tc1 `compare` tc2) `thenCmp` (cmps env tys1 tys2) + cmp env (ForAllTy tv1 t1) (ForAllTy tv2 t2) = cmp (extendVarEnv env tv1 tv2) t1 t2 + + -- Deal with the rest: TyVarTy < AppTy < FunTy < TyConApp < ForAllTy + cmp env (AppTy _ _) (TyVarTy _) = GT + + cmp env (FunTy _ _) (TyVarTy _) = GT + cmp env (FunTy _ _) (AppTy _ _) = GT + + cmp env (TyConApp _ _) (TyVarTy _) = GT + cmp env (TyConApp _ _) (AppTy _ _) = GT + cmp env (TyConApp _ _) (FunTy _ _) = GT + + cmp env (ForAllTy _ _) other = GT + + cmp env _ _ = LT + + cmps env [] [] = EQ + cmps env (t:ts) [] = GT + cmps env [] (t:ts) = LT + cmps env (t1:t1s) (t2:t2s) = cmp env t1 t2 `thenCmp` cmps env t1s t2s \end{code} -@match@ is the main function. -\begin{code} -match :: [(t1, GenType t2 u2)] -- r, the accumulating result - -> [(GenType t1 u1, GenType t2 u2)] -- w, the work list - -> GenType t1 u1 -> GenType t2 u2 -- Current match pair - -> Maybe [(t1, GenType t2 u2)] - -match r w (TyVarTy v) ty = match' ((v,ty) : r) w -match r w (FunTy fun1 arg1 _) (FunTy fun2 arg2 _) = match r ((fun1,fun2):w) arg1 arg2 -match r w (AppTy fun1 arg1) (AppTy fun2 arg2) = match r ((fun1,fun2):w) arg1 arg2 -match r w (TyConTy con1 _) (TyConTy con2 _) | con1 == con2 = match' r w -match r w (DictTy clas1 ty1 _) (DictTy clas2 ty2 _) | clas1 == clas2 = match r w ty1 ty2 -match r w (SynTy _ _ ty1) ty2 = match r w ty1 ty2 -match r w ty1 (SynTy _ _ ty2) = match r w ty1 ty2 - - -- With type synonyms, we have to be careful for the exact - -- same reasons as in the unifier. Please see the - -- considerable commentary there before changing anything - -- here! (WDP 95/05) - --- Catch-all fails -match _ _ _ _ = Nothing - -match' r [] = Just r -match' r ((ty1,ty2):w) = match r w ty1 ty2 -\end{code} %************************************************************************ %* * -\subsection{Equality on types} +\subsection{Grime} %* * %************************************************************************ -The functions eqSimpleTy and eqSimpleTheta are polymorphic in the types t -and u, but ONLY WORK FOR SIMPLE TYPES (ie. they panic if they see -dictionaries or polymorphic types). The function eqTy has a more -specific type, but does the `right thing' for all types. - -\begin{code} -eqSimpleTheta :: (Eq t,Eq u) => - [(Class,GenType t u)] -> [(Class,GenType t u)] -> Bool -eqSimpleTheta [] [] = True -eqSimpleTheta ((c1,t1):th1) ((c2,t2):th2) = - c1==c2 && t1 `eqSimpleTy` t2 && th1 `eqSimpleTheta` th2 -eqSimpleTheta other1 other2 = False -\end{code} \begin{code} -eqSimpleTy :: (Eq t,Eq u) => GenType t u -> GenType t u -> Bool - -(TyVarTy tv1) `eqSimpleTy` (TyVarTy tv2) = - tv1 == tv2 -(AppTy f1 a1) `eqSimpleTy` (AppTy f2 a2) = - f1 `eqSimpleTy` f2 && a1 `eqSimpleTy` a2 -(TyConTy tc1 u1) `eqSimpleTy` (TyConTy tc2 u2) = - tc1 == tc2 && u1 == u2 - -(FunTy f1 a1 u1) `eqSimpleTy` (FunTy f2 a2 u2) = - f1 `eqSimpleTy` f2 && a1 `eqSimpleTy` a2 && u1 == u2 -(FunTy f1 a1 u1) `eqSimpleTy` t2 = - -- Expand t1 just in case t2 matches that version - (AppTy (AppTy (TyConTy mkFunTyCon u1) f1) a1) `eqSimpleTy` t2 -t1 `eqSimpleTy` (FunTy f2 a2 u2) = - -- Expand t2 just in case t1 matches that version - t1 `eqSimpleTy` (AppTy (AppTy (TyConTy mkFunTyCon u2) f2) a2) - -(SynTy tc1 ts1 t1) `eqSimpleTy` (SynTy tc2 ts2 t2) = - (tc1 == tc2 && and (zipWith eqSimpleTy ts1 ts2) && length ts1 == length ts2) - || t1 `eqSimpleTy` t2 -(SynTy _ _ t1) `eqSimpleTy` t2 = - t1 `eqSimpleTy` t2 -- Expand the abbrevation and try again -t1 `eqSimpleTy` (SynTy _ _ t2) = - t1 `eqSimpleTy` t2 -- Expand the abbrevation and try again - -(DictTy _ _ _) `eqSimpleTy` _ = panic "eqSimpleTy: got DictTy" -_ `eqSimpleTy` (DictTy _ _ _) = panic "eqSimpleTy: got DictTy" - -(ForAllTy _ _) `eqSimpleTy` _ = panic "eqSimpleTy: got ForAllTy" -_ `eqSimpleTy` (ForAllTy _ _) = panic "eqSimpleTy: got ForAllTy" - -(ForAllUsageTy _ _ _) `eqSimpleTy` _ = panic "eqSimpleTy: got ForAllUsageTy" -_ `eqSimpleTy` (ForAllUsageTy _ _ _) = panic "eqSimpleTy: got ForAllUsageTy" - -_ `eqSimpleTy` _ = False -\end{code} - -Types are ordered so we can sort on types in the renamer etc. DNT: Since -this class is also used in CoreLint and other such places, we DO expand out -Fun/Syn/Dict types (if necessary). - -\begin{code} -eqTy :: Type -> Type -> Bool - -eqTy t1 t2 = - eq nullTyVarEnv nullUVarEnv t1 t2 - where - eq tve uve (TyVarTy tv1) (TyVarTy tv2) = - tv1 == tv2 || - case (lookupTyVarEnv tve tv1) of - Just tv -> tv == tv2 - Nothing -> False - eq tve uve (AppTy f1 a1) (AppTy f2 a2) = - eq tve uve f1 f2 && eq tve uve a1 a2 - eq tve uve (TyConTy tc1 u1) (TyConTy tc2 u2) = - tc1 == tc2 && eqUsage uve u1 u2 - - eq tve uve (FunTy f1 a1 u1) (FunTy f2 a2 u2) = - eq tve uve f1 f2 && eq tve uve a1 a2 && eqUsage uve u1 u2 - eq tve uve (FunTy f1 a1 u1) t2 = - -- Expand t1 just in case t2 matches that version - eq tve uve (AppTy (AppTy (TyConTy mkFunTyCon u1) f1) a1) t2 - eq tve uve t1 (FunTy f2 a2 u2) = - -- Expand t2 just in case t1 matches that version - eq tve uve t1 (AppTy (AppTy (TyConTy mkFunTyCon u2) f2) a2) - - eq tve uve (DictTy c1 t1 u1) (DictTy c2 t2 u2) - | c1 == c2 - = eq tve uve t1 t2 && eqUsage uve u1 u2 - -- NB we use a guard for c1==c2 so that if they aren't equal we - -- fall through into expanding the type. Why? Because brain-dead - -- people might write - -- class Foo a => Baz a where {} - -- and that means that a Foo dictionary and a Baz dictionary are identical - -- Sigh. Let's hope we don't spend too much time in here! - - eq tve uve t1@(DictTy _ _ _) t2 = - eq tve uve (expandTy t1) t2 -- Expand the dictionary and try again - eq tve uve t1 t2@(DictTy _ _ _) = - eq tve uve t1 (expandTy t2) -- Expand the dictionary and try again - - eq tve uve (SynTy tc1 ts1 t1) (SynTy tc2 ts2 t2) = - (tc1 == tc2 && and (zipWith (eq tve uve) ts1 ts2) && length ts1 == length ts2) - || eq tve uve t1 t2 - eq tve uve (SynTy _ _ t1) t2 = - eq tve uve t1 t2 -- Expand the abbrevation and try again - eq tve uve t1 (SynTy _ _ t2) = - eq tve uve t1 t2 -- Expand the abbrevation and try again - - eq tve uve (ForAllTy tv1 t1) (ForAllTy tv2 t2) = - eq (addOneToTyVarEnv tve tv1 tv2) uve t1 t2 - eq tve uve (ForAllUsageTy u1 b1 t1) (ForAllUsageTy u2 b2 t2) = - eqBounds uve b1 b2 && eq tve (addOneToUVarEnv uve u1 u2) t1 t2 - - eq _ _ _ _ = False - - eqBounds uve [] [] = True - eqBounds uve (u1:b1) (u2:b2) = eqUVar uve u1 u2 && eqBounds uve b1 b2 - eqBounds uve _ _ = False +showTypeCategory :: Type -> Char + {- + {C,I,F,D} char, int, float, double + T tuple + S other single-constructor type + {c,i,f,d} unboxed ditto + t *unpacked* tuple + s *unpacked" single-cons... + + v void# + a primitive array + + E enumeration type + + dictionary, unless it's a ... + L List + > function + M other (multi-constructor) data-con type + . other type + - reserved for others to mark as "uninteresting" + -} +showTypeCategory ty + = if isDictTy ty + then '+' + else + case splitTyConApp_maybe ty of + Nothing -> if maybeToBool (splitFunTy_maybe ty) + then '>' + else '.' + + Just (tycon, _) -> + let utc = getUnique tycon in + if utc == charDataConKey then 'C' + else if utc == intDataConKey then 'I' + else if utc == floatDataConKey then 'F' + else if utc == doubleDataConKey then 'D' + else if utc == integerDataConKey then 'J' + else if utc == charPrimTyConKey then 'c' + else if (utc == intPrimTyConKey || utc == wordPrimTyConKey + || utc == addrPrimTyConKey) then 'i' + else if utc == floatPrimTyConKey then 'f' + else if utc == doublePrimTyConKey then 'd' + else if isPrimTyCon tycon {- array, we hope -} then 'A' + else if isEnumerationTyCon tycon then 'E' + else if isTupleTyCon tycon then 'T' + else if maybeToBool (maybeTyConSingleCon tycon) then 'S' + else if utc == listTyConKey then 'L' + else 'M' -- oh, well... \end{code}