X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypes%2FTyCon.lhs;h=6f1ac543aab7dfc6b6dc3cb08e451bf3fd37646b;hb=fa6b1e4523a9d8a1fe85a95e5c69e767746cbe7d;hp=a2048a5ab9056503aa99c9e3050b2b28dc5ab5ac;hpb=28139aea50376444d56f43f0914291348a51a7e7;p=ghc-hetmet.git diff --git a/ghc/compiler/types/TyCon.lhs b/ghc/compiler/types/TyCon.lhs index a2048a5..6f1ac54 100644 --- a/ghc/compiler/types/TyCon.lhs +++ b/ghc/compiler/types/TyCon.lhs @@ -1,307 +1,550 @@ - -% (c) The GRASP/AQUA Project, Glasgow University, 1992-1996 +% +% (c) The GRASP/AQUA Project, Glasgow University, 1992-1998 % \section[TyCon]{The @TyCon@ datatype} \begin{code} module TyCon( - TyCon, + TyCon, KindCon, SuperKindCon, ArgVrcs, - Arity, NewOrData(..), + AlgTyConFlavour(..), + DataConDetails(..), visibleDataCons, - isFunTyCon, isPrimTyCon, isBoxedTyCon, isProductTyCon, - isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, - isEnumerationTyCon, isTupleTyCon, + isFunTyCon, isUnLiftedTyCon, isBoxedTyCon, isProductTyCon, + isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, isPrimTyCon, + isEnumerationTyCon, + isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity, + isRecursiveTyCon, newTyConRep, - mkDataTyCon, + mkForeignTyCon, isForeignTyCon, + + mkAlgTyCon, + mkClassTyCon, mkFunTyCon, mkPrimTyCon, - mkSpecTyCon, + mkLiftedPrimTyCon, mkTupleTyCon, - mkSynTyCon, + mkKindCon, + mkSuperKindCon, + setTyConName, + + tyConName, tyConKind, tyConUnique, tyConTyVars, - tyConDataCons, - tyConFamilySize, - tyConDerivings, + tyConArgVrcs_maybe, + tyConDataConDetails, tyConDataCons, tyConDataCons_maybe, tyConFamilySize, + tyConSelIds, tyConTheta, tyConPrimRep, tyConArity, - tyConClass_maybe, + isClassTyCon, tyConClass_maybe, getSynTyConDefn, - maybeTyConSingleCon + maybeTyConSingleCon, + + matchesTyCon, + + -- Generics + tyConGenIds, tyConGenInfo ) where #include "HsVersions.h" -import {-# SOURCE #-} Type ( Type ) -import {-# SOURCE #-} Class ( Class ) -import {-# SOURCE #-} Id ( Id, isNullaryDataCon, idType ) -import {-# SOURCE #-} TysWiredIn ( tupleCon ) +import {-# SOURCE #-} TypeRep ( Type, PredType, Kind, SuperKind ) + -- Should just be Type(Type), but this fails due to bug present up to + -- and including 4.02 involving slurping of hi-boot files. Bug is now fixed. +import {-# SOURCE #-} DataCon ( DataCon, isExistentialDataCon ) -import BasicTypes ( Arity, NewOrData(..), RecFlag(..) ) -import TyVar ( GenTyVar, alphaTyVars, alphaTyVar, betaTyVar, TyVar ) -import Kind ( Kind, mkBoxedTypeKind, mkTypeKind, mkUnboxedTypeKind, - mkArrowKind, resultKind, argKind - ) -import Maybes -import Name ( Name, nameUnique, mkWiredInTyConName, NamedThing(getName) ) -import Unique ( Unique, funTyConKey, Uniquable(..) ) + +import Var ( TyVar, Id ) +import Class ( Class ) +import BasicTypes ( Arity, RecFlag(..), Boxity(..), + isBoxed, EP(..) ) +import Name ( Name, nameUnique, NamedThing(getName) ) +import PrelNames ( Unique, Uniquable(..), anyBoxConKey ) import PrimRep ( PrimRep(..), isFollowableRep ) -import PrelMods ( pREL_GHC, pREL_TUP, pREL_BASE ) -import Lex ( mkTupNameStr ) -import SrcLoc ( SrcLoc, mkBuiltinSrcLoc ) -import Util ( nOfThem, isIn ) +import Maybes ( orElse ) import Outputable +import FastString \end{code} -\begin{code} -data TyCon - = FunTyCon -- Kind = Type -> Type -> Type - - | DataTyCon Unique - Name - Kind - [TyVar] - [(Class,[Type])] -- Its context - [Id{-DataCon-}] -- Its data constructors, with fully polymorphic types - -- This list can be empty, when we import a data type abstractly, - -- either (a) the interface is hand-written and doesn't give - -- the constructors, or - -- (b) in a quest for fast compilation we don't import - -- the constructors - [Class] -- Classes which have derived instances - (Maybe Class) -- Nothing for ordinary types; Just c for the type constructor - -- for dictionaries of class c. - NewOrData - RecFlag -- Tells whether the data type is part of - -- a mutually-recursive group or not - - | TupleTyCon Unique -- cached - Name -- again, we could do without this, but - -- it makes life somewhat easier - Arity -- just a special case of DataTyCon - -- Kind = BoxedTypeKind - -- -> ... (n times) ... - -- -> BoxedTypeKind - -- -> BoxedTypeKind - - | PrimTyCon -- Primitive types; cannot be defined in Haskell - Unique -- Always unpointed; hence never represented by a closure - Name -- Often represented by a bit-pattern for the thing - Kind -- itself (eg Int#), but sometimes by a pointer to - Arity -- the thing. - PrimRep - - | SpecTyCon -- A specialised TyCon; eg (Arr# Int#), or (List Int#) - TyCon - [Maybe Type] -- Specialising types - - -- OLD STUFF ABOUT Array types. Use SpecTyCon instead - -- ([PrimRep] -> PrimRep) -- a heap-allocated object (eg ArrInt#). - -- The primitive types Arr# and StablePtr# have - -- parameters (hence arity /= 0); but the rest don't. - -- Only arrays use the list in a non-trivial way. - -- Length of that list must == arity. - - | SynTyCon - Unique - Name - Kind - Arity - [TyVar] -- Argument type variables - Type -- Right-hand side, mentioning these type vars. - -- Acts as a template for the expansion when - -- the tycon is applied to some types. -\end{code} +%************************************************************************ +%* * +\subsection{The data type} +%* * +%************************************************************************ \begin{code} -mkFunTyCon = FunTyCon -mkFunTyConName = mkWiredInTyConName funTyConKey pREL_GHC SLIT("->") FunTyCon +type KindCon = TyCon +type SuperKindCon = TyCon -mkSpecTyCon = SpecTyCon -mkTupleTyCon = TupleTyCon +data TyCon + = FunTyCon { + tyConUnique :: Unique, + tyConName :: Name, + tyConKind :: Kind, + tyConArity :: Arity + } + + + | AlgTyCon { -- Tuples, data type, and newtype decls. + -- All lifted, all boxed + tyConUnique :: Unique, + tyConName :: Name, + tyConKind :: Kind, + tyConArity :: Arity, + + tyConTyVars :: [TyVar], + tyConArgVrcs :: ArgVrcs, + algTyConTheta :: [PredType], + + dataCons :: DataConDetails DataCon, + + selIds :: [Id], -- Its record selectors (if any) + + algTyConFlavour :: AlgTyConFlavour, + algTyConRec :: RecFlag, -- Tells whether the data type is part of + -- a mutually-recursive group or not + + genInfo :: Maybe (EP Id), -- Convert T <-> Tring + -- Some TyCons don't have it; + -- e.g. the TyCon for a Class dictionary, + -- and TyCons with unboxed arguments + + algTyConClass :: Maybe Class + -- Just cl if this tycon came from a class declaration + } + + | PrimTyCon { -- Primitive types; cannot be defined in Haskell + -- Now includes foreign-imported types + tyConUnique :: Unique, + tyConName :: Name, + tyConKind :: Kind, + tyConArity :: Arity, + tyConArgVrcs :: ArgVrcs, + primTyConRep :: PrimRep, -- Many primitive tycons are unboxed, but some are + -- boxed (represented by pointers). The PrimRep tells. + + isUnLifted :: Bool, -- Most primitive tycons are unlifted, + -- but foreign-imported ones may not be + tyConExtName :: Maybe FastString + } + + | TupleTyCon { + + tyConUnique :: Unique, + tyConName :: Name, + tyConKind :: Kind, + tyConArity :: Arity, + tyConBoxed :: Boxity, + tyConTyVars :: [TyVar], + dataCon :: DataCon, + genInfo :: Maybe (EP Id) -- Generic type and conv funs + } + + | SynTyCon { + tyConUnique :: Unique, + tyConName :: Name, + tyConKind :: Kind, + tyConArity :: Arity, + + tyConTyVars :: [TyVar], -- Bound tyvars + synTyConDefn :: Type, -- Right-hand side, mentioning these type vars. + -- Acts as a template for the expansion when + -- the tycon is applied to some types. + tyConArgVrcs :: ArgVrcs + } + + | KindCon { -- Type constructor at the kind level + tyConUnique :: Unique, + tyConName :: Name, + tyConKind :: SuperKind, + tyConArity :: Arity + } + + | SuperKindCon { -- The type of kind variables or boxity variables, + tyConUnique :: Unique, + tyConName :: Name + } + +type ArgVrcs = [(Bool,Bool)] -- Tyvar variance info: [(occPos,occNeg)] + +data AlgTyConFlavour + = DataTyCon -- Data type + + | EnumTyCon -- Special sort of enumeration type + + | NewTyCon Type -- Newtype, with its *ultimate* representation type + -- By 'ultimate' I mean that the rep type is not itself + -- a newtype or type synonym. + -- The rep type isn't entirely simple: + -- for a recursive newtype we pick () as the rep type + -- newtype T = MkT T + -- + -- The rep type has free type variables the tyConTyVars + -- Thus: + -- newtype T a = MkT [(a,Int)] + -- The rep type is [(a,Int)] + -- NB: the rep type isn't necessarily the original RHS of the + -- newtype decl, because the rep type looks through other + -- newtypes. If you want hte original RHS, look at the + -- argument type of the data constructor. + +data DataConDetails datacon + = DataCons [datacon] -- Its data constructors, with fully polymorphic types + -- A type can have zero constructors + + | Unknown -- We're importing this data type from an hi-boot file + -- and we don't know what its constructors are + + | HasCons Int -- In a quest for compilation speed we have imported + -- only the number of constructors (to get return + -- conventions right) but not the constructors themselves + +visibleDataCons (DataCons cs) = cs +visibleDataCons other = [] +\end{code} -mkDataTyCon name = DataTyCon (nameUnique name) name -mkPrimTyCon name arity rep - = PrimTyCon (nameUnique name) name (mk_kind arity) arity rep - where - mk_kind 0 | isFollowableRep rep = mkBoxedTypeKind -- Represented by a GC-ish ptr - | otherwise = mkUnboxedTypeKind -- Represented by a non-ptr - mk_kind n = mkTypeKind `mkArrowKind` mk_kind (n-1) +%************************************************************************ +%* * +\subsection{TyCon Construction} +%* * +%************************************************************************ -mkSynTyCon name = SynTyCon (nameUnique name) name +Note: the TyCon constructors all take a Kind as one argument, even though +they could, in principle, work out their Kind from their other arguments. +But to do so they need functions from Types, and that makes a nasty +module mutual-recursion. And they aren't called from many places. +So we compromise, and move their Kind calculation to the call site. -isFunTyCon FunTyCon = True -isFunTyCon _ = False +\begin{code} +mkSuperKindCon :: Name -> SuperKindCon +mkSuperKindCon name = SuperKindCon { + tyConUnique = nameUnique name, + tyConName = name + } + +mkKindCon :: Name -> SuperKind -> KindCon +mkKindCon name kind + = KindCon { + tyConUnique = nameUnique name, + tyConName = name, + tyConArity = 0, + tyConKind = kind + } + +mkFunTyCon :: Name -> Kind -> TyCon +mkFunTyCon name kind + = FunTyCon { + tyConUnique = nameUnique name, + tyConName = name, + tyConKind = kind, + tyConArity = 2 + } + +tyConGenInfo :: TyCon -> Maybe (EP Id) +tyConGenInfo (AlgTyCon { genInfo = info }) = info +tyConGenInfo (TupleTyCon { genInfo = info }) = info +tyConGenInfo other = Nothing + +tyConGenIds :: TyCon -> [Id] +-- Returns the generic-programming Ids; these Ids need bindings +tyConGenIds tycon = case tyConGenInfo tycon of + Nothing -> [] + Just (EP from to) -> [from,to] + +-- This is the making of a TyCon. Just the same as the old mkAlgTyCon, +-- but now you also have to pass in the generic information about the type +-- constructor - you can get hold of it easily (see Generics module) +mkAlgTyCon name kind tyvars theta argvrcs cons sels flavour is_rec + gen_info + = AlgTyCon { + tyConName = name, + tyConUnique = nameUnique name, + tyConKind = kind, + tyConArity = length tyvars, + tyConTyVars = tyvars, + tyConArgVrcs = argvrcs, + algTyConTheta = theta, + dataCons = cons, + selIds = sels, + algTyConClass = Nothing, + algTyConFlavour = flavour, + algTyConRec = is_rec, + genInfo = gen_info + } + +mkClassTyCon name kind tyvars argvrcs con clas flavour is_rec + = AlgTyCon { + tyConName = name, + tyConUnique = nameUnique name, + tyConKind = kind, + tyConArity = length tyvars, + tyConTyVars = tyvars, + tyConArgVrcs = argvrcs, + algTyConTheta = [], + dataCons = DataCons [con], + selIds = [], + algTyConClass = Just clas, + algTyConFlavour = flavour, + algTyConRec = is_rec, + genInfo = Nothing + } + + +mkTupleTyCon name kind arity tyvars con boxed gen_info + = TupleTyCon { + tyConUnique = nameUnique name, + tyConName = name, + tyConKind = kind, + tyConArity = arity, + tyConBoxed = boxed, + tyConTyVars = tyvars, + dataCon = con, + genInfo = gen_info + } + +-- Foreign-imported (.NET) type constructors are represented +-- as primitive, but *lifted*, TyCons for now. They are lifted +-- because the Haskell type T representing the (foreign) .NET +-- type T is actually implemented (in ILX) as a thunk +-- They have PtrRep +mkForeignTyCon name ext_name kind arity arg_vrcs + = PrimTyCon { + tyConName = name, + tyConUnique = nameUnique name, + tyConKind = kind, + tyConArity = arity, + tyConArgVrcs = arg_vrcs, + primTyConRep = PtrRep, + isUnLifted = False, + tyConExtName = ext_name + } + + +-- most Prim tycons are lifted +mkPrimTyCon name kind arity arg_vrcs rep + = mkPrimTyCon' name kind arity arg_vrcs rep True + +-- but RealWorld is lifted +mkLiftedPrimTyCon name kind arity arg_vrcs rep + = mkPrimTyCon' name kind arity arg_vrcs rep False + +mkPrimTyCon' name kind arity arg_vrcs rep is_unlifted + = PrimTyCon { + tyConName = name, + tyConUnique = nameUnique name, + tyConKind = kind, + tyConArity = arity, + tyConArgVrcs = arg_vrcs, + primTyConRep = rep, + isUnLifted = is_unlifted, + tyConExtName = Nothing + } + +mkSynTyCon name kind arity tyvars rhs argvrcs + = SynTyCon { + tyConName = name, + tyConUnique = nameUnique name, + tyConKind = kind, + tyConArity = arity, + tyConTyVars = tyvars, + synTyConDefn = rhs, + tyConArgVrcs = argvrcs + } + +setTyConName tc name = tc {tyConName = name, tyConUnique = nameUnique name} -isPrimTyCon (PrimTyCon _ _ _ _ _) = True -isPrimTyCon _ = False +\end{code} --- At present there are no unboxed non-primitive types, so --- isBoxedTyCon is just the negation of isPrimTyCon. -isBoxedTyCon = not . isPrimTyCon +\begin{code} +isFunTyCon :: TyCon -> Bool +isFunTyCon (FunTyCon {}) = True +isFunTyCon _ = False + +isPrimTyCon :: TyCon -> Bool +isPrimTyCon (PrimTyCon {}) = True +isPrimTyCon _ = False + +isUnLiftedTyCon :: TyCon -> Bool +isUnLiftedTyCon (PrimTyCon {isUnLifted = is_unlifted}) = is_unlifted +isUnLiftedTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity) +isUnLiftedTyCon _ = False + +-- isBoxedTyCon should not be applied to SynTyCon, nor KindCon +isBoxedTyCon :: TyCon -> Bool +isBoxedTyCon (AlgTyCon {}) = True +isBoxedTyCon (FunTyCon {}) = True +isBoxedTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity +isBoxedTyCon (PrimTyCon {primTyConRep = rep}) = isFollowableRep rep -- isAlgTyCon returns True for both @data@ and @newtype@ -isAlgTyCon (DataTyCon _ _ _ _ _ _ _ _ _ _) = True -isAlgTyCon (TupleTyCon _ _ _) = True -isAlgTyCon other = False - --- isDataTyCon returns False for @newtype@. -isDataTyCon (DataTyCon _ _ _ _ _ _ _ _ DataType _) = True -isDataTyCon (TupleTyCon _ _ _) = True -isDataTyCon other = False - -isNewTyCon (DataTyCon _ _ _ _ _ _ _ _ NewType _) = True -isNewTyCon other = False - --- A "product" tycon is non-recursive and has one constructor, --- whether DataType or NewType -isProductTyCon (TupleTyCon _ _ _) = True -isProductTyCon (DataTyCon _ _ _ _ _ [c] _ _ _ NonRecursive) = True -isProductTyCon other = False - -isSynTyCon (SynTyCon _ _ _ _ _ _) = True -isSynTyCon _ = False - -isEnumerationTyCon (TupleTyCon _ _ arity) - = arity == 0 -isEnumerationTyCon (DataTyCon _ _ _ _ _ data_cons _ _ DataType _) - = not (null data_cons) && all isNullaryDataCon data_cons -isEnumerationTyCon other = False - -isTupleTyCon (TupleTyCon _ _ arity) = arity >= 2 -- treat "0-tuple" specially -isTupleTyCon (SpecTyCon tc tys) = isTupleTyCon tc -isTupleTyCon other = False +isAlgTyCon :: TyCon -> Bool +isAlgTyCon (AlgTyCon {}) = True +isAlgTyCon (TupleTyCon {}) = True +isAlgTyCon other = False + +isDataTyCon :: TyCon -> Bool +-- isDataTyCon returns True for data types that are represented by +-- heap-allocated constructors. +-- These are srcutinised by Core-level @case@ expressions, and they +-- get info tables allocated for them. +-- True for all @data@ types +-- False for newtypes +-- unboxed tuples +isDataTyCon (AlgTyCon {algTyConFlavour = new_or_data}) + = case new_or_data of + NewTyCon _ -> False + other -> True + +isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity +isDataTyCon other = False + +isNewTyCon :: TyCon -> Bool +isNewTyCon (AlgTyCon {algTyConFlavour = NewTyCon _}) = True +isNewTyCon other = False + +isProductTyCon :: TyCon -> Bool +-- A "product" tycon +-- has *one* constructor, +-- is *not* existential +-- but +-- may be DataType or NewType, +-- may be unboxed or not, +-- may be recursive or not +isProductTyCon (AlgTyCon {dataCons = DataCons [data_con]}) = not (isExistentialDataCon data_con) +isProductTyCon (TupleTyCon {}) = True +isProductTyCon other = False + +isSynTyCon :: TyCon -> Bool +isSynTyCon (SynTyCon {}) = True +isSynTyCon _ = False + +isEnumerationTyCon :: TyCon -> Bool +isEnumerationTyCon (AlgTyCon {algTyConFlavour = EnumTyCon}) = True +isEnumerationTyCon other = False + +isTupleTyCon :: TyCon -> Bool +-- The unit tycon didn't used to be classed as a tuple tycon +-- but I thought that was silly so I've undone it +-- If it can't be for some reason, it should be a AlgTyCon +isTupleTyCon (TupleTyCon {}) = True +isTupleTyCon other = False + +isUnboxedTupleTyCon :: TyCon -> Bool +isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity) +isUnboxedTupleTyCon other = False + +isBoxedTupleTyCon :: TyCon -> Bool +isBoxedTupleTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity +isBoxedTupleTyCon other = False + +tupleTyConBoxity tc = tyConBoxed tc + +isRecursiveTyCon :: TyCon -> Bool +isRecursiveTyCon (AlgTyCon {algTyConRec = Recursive}) = True +isRecursiveTyCon other = False + +isForeignTyCon :: TyCon -> Bool +-- isForeignTyCon identifies foreign-imported type constructors +-- For the moment, they are primitive but lifted, but that may change +isForeignTyCon (PrimTyCon {isUnLifted = is_unlifted}) = not is_unlifted +isForeignTyCon other = False \end{code} \begin{code} --- Special cases to avoid reconstructing lots of kinds -kind1 = mkBoxedTypeKind `mkArrowKind` mkBoxedTypeKind -kind2 = mkBoxedTypeKind `mkArrowKind` kind1 - -tyConKind :: TyCon -> Kind -tyConKind FunTyCon = kind2 -tyConKind (DataTyCon _ _ kind _ _ _ _ _ _ _) = kind -tyConKind (PrimTyCon _ _ kind _ _) = kind -tyConKind (SynTyCon _ _ k _ _ _) = k - -tyConKind (TupleTyCon _ _ n) - = mkArrow n - where - mkArrow 0 = mkBoxedTypeKind - mkArrow 1 = kind1 - mkArrow 2 = kind2 - mkArrow n = mkBoxedTypeKind `mkArrowKind` mkArrow (n-1) - -tyConKind (SpecTyCon tc tys) - = spec (tyConKind tc) tys - where - spec kind [] = kind - spec kind (Just _ : tys) = spec (resultKind kind) tys - spec kind (Nothing : tys) = - argKind kind `mkArrowKind` spec (resultKind kind) tys -\end{code} +tyConDataConDetails :: TyCon -> DataConDetails DataCon +tyConDataConDetails (AlgTyCon {dataCons = cons}) = cons +tyConDataConDetails (TupleTyCon {dataCon = con}) = DataCons [con] +tyConDataConDetails other = Unknown -\begin{code} -tyConUnique :: TyCon -> Unique -tyConUnique FunTyCon = funTyConKey -tyConUnique (DataTyCon uniq _ _ _ _ _ _ _ _ _) = uniq -tyConUnique (TupleTyCon uniq _ _) = uniq -tyConUnique (PrimTyCon uniq _ _ _ _) = uniq -tyConUnique (SynTyCon uniq _ _ _ _ _) = uniq -tyConUnique (SpecTyCon _ _ ) = panic "tyConUnique:SpecTyCon" - -tyConArity :: TyCon -> Arity -tyConArity FunTyCon = 2 -tyConArity (DataTyCon _ _ _ tyvars _ _ _ _ _ _) = length tyvars -tyConArity (TupleTyCon _ _ arity) = arity -tyConArity (PrimTyCon _ _ _ arity _) = arity -tyConArity (SynTyCon _ _ _ arity _ _) = arity -tyConArity (SpecTyCon _ _ ) = panic "tyConArity:SpecTyCon" -\end{code} +tyConDataCons :: TyCon -> [DataCon] +-- It's convenient for tyConDataCons to return the +-- empty list for type synonyms etc +tyConDataCons tycon = tyConDataCons_maybe tycon `orElse` [] -\begin{code} -tyConTyVars :: TyCon -> [TyVar] -tyConTyVars FunTyCon = [alphaTyVar,betaTyVar] -tyConTyVars (DataTyCon _ _ _ tvs _ _ _ _ _ _) = tvs -tyConTyVars (TupleTyCon _ _ arity) = take arity alphaTyVars -tyConTyVars (SynTyCon _ _ _ _ tvs _) = tvs +tyConDataCons_maybe :: TyCon -> Maybe [DataCon] +tyConDataCons_maybe (AlgTyCon {dataCons = DataCons cons}) = Just cons +tyConDataCons_maybe (TupleTyCon {dataCon = con}) = Just [con] +tyConDataCons_maybe other = Nothing + +tyConFamilySize :: TyCon -> Int +tyConFamilySize (AlgTyCon {dataCons = DataCons cs}) = length cs +tyConFamilySize (AlgTyCon {dataCons = HasCons n}) = n +tyConFamilySize (TupleTyCon {}) = 1 #ifdef DEBUG -tyConTyVars (PrimTyCon _ _ _ _ _) = panic "tyConTyVars:PrimTyCon" -tyConTyVars (SpecTyCon _ _ ) = panic "tyConTyVars:SpecTyCon" +tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other) #endif + +tyConSelIds :: TyCon -> [Id] +tyConSelIds (AlgTyCon {selIds = sels}) = sels +tyConSelIds other_tycon = [] \end{code} \begin{code} -tyConDataCons :: TyCon -> [Id] -tyConFamilySize :: TyCon -> Int - -tyConDataCons (DataTyCon _ _ _ _ _ data_cons _ _ _ _) = data_cons -tyConDataCons (TupleTyCon _ _ a) = [tupleCon a] -tyConDataCons other = [] - -- You may think this last equation should fail, - -- but it's quite convenient to return no constructors for - -- a synonym; see for example the call in TcTyClsDecls. - -tyConFamilySize (DataTyCon _ _ _ _ _ data_cons _ _ _ _) = length data_cons -tyConFamilySize (TupleTyCon _ _ _) = 1 -#ifdef DEBUG ---tyConFamilySize other = pprPanic "tyConFamilySize:" (pprTyCon other) -#endif +newTyConRep :: TyCon -> ([TyVar], Type) +newTyConRep (AlgTyCon {tyConTyVars = tvs, algTyConFlavour = NewTyCon rep}) = (tvs, rep) tyConPrimRep :: TyCon -> PrimRep -tyConPrimRep (PrimTyCon _ __ _ rep) = rep -tyConPrimRep _ = PtrRep +tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep +tyConPrimRep tc = ASSERT( not (isUnboxedTupleTyCon tc) ) + PtrRep + -- We should not be asking what the representation of an + -- unboxed tuple is, because it isn't a first class value. \end{code} \begin{code} -tyConDerivings :: TyCon -> [Class] -tyConDerivings (DataTyCon _ _ _ _ _ _ derivs _ _ _) = derivs -tyConDerivings other = [] +tyConTheta :: TyCon -> [PredType] +tyConTheta (AlgTyCon {algTyConTheta = theta}) = theta +tyConTheta (TupleTyCon {}) = [] +-- shouldn't ask about anything else \end{code} +@tyConArgVrcs_maybe@ gives a list of (occPos,occNeg) flags, one for +each tyvar, if available. See @calcAlgTyConArgVrcs@ for how this is +actually computed (in another file). + \begin{code} -tyConTheta :: TyCon -> [(Class, [Type])] -tyConTheta (DataTyCon _ _ _ _ theta _ _ _ _ _) = theta -tyConTheta (TupleTyCon _ _ _) = [] --- should ask about anything else +tyConArgVrcs_maybe :: TyCon -> Maybe ArgVrcs + +tyConArgVrcs_maybe (FunTyCon {} ) = Just [(False,True),(True,False)] +tyConArgVrcs_maybe (AlgTyCon {tyConArgVrcs = oi}) = Just oi +tyConArgVrcs_maybe (PrimTyCon {tyConArgVrcs = oi}) = Just oi +tyConArgVrcs_maybe (TupleTyCon {tyConArity = arity }) = Just (replicate arity (True,False)) +tyConArgVrcs_maybe (SynTyCon {tyConArgVrcs = oi }) = Just oi +tyConArgVrcs_maybe _ = Nothing \end{code} \begin{code} getSynTyConDefn :: TyCon -> ([TyVar], Type) -getSynTyConDefn (SynTyCon _ _ _ _ tyvars ty) = (tyvars,ty) +getSynTyConDefn (SynTyCon {tyConTyVars = tyvars, synTyConDefn = ty}) = (tyvars,ty) \end{code} \begin{code} -maybeTyConSingleCon :: TyCon -> Maybe Id - -maybeTyConSingleCon (TupleTyCon _ _ arity) = Just (tupleCon arity) -maybeTyConSingleCon (DataTyCon _ _ _ _ _ [c] _ _ _ _) = Just c -maybeTyConSingleCon (DataTyCon _ _ _ _ _ _ _ _ _ _) = Nothing -maybeTyConSingleCon (PrimTyCon _ _ _ _ _) = Nothing -maybeTyConSingleCon (SpecTyCon tc tys) = panic "maybeTyConSingleCon:SpecTyCon" - -- requires DataCons of TyCon +maybeTyConSingleCon :: TyCon -> Maybe DataCon +maybeTyConSingleCon (AlgTyCon {dataCons = DataCons [c]}) = Just c +maybeTyConSingleCon (AlgTyCon {}) = Nothing +maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con +maybeTyConSingleCon (PrimTyCon {}) = Nothing +maybeTyConSingleCon (FunTyCon {}) = Nothing -- case at funty +maybeTyConSingleCon tc = pprPanic "maybeTyConSingleCon: unexpected tycon " $ ppr tc \end{code} \begin{code} +isClassTyCon :: TyCon -> Bool +isClassTyCon (AlgTyCon {algTyConClass = Just _}) = True +isClassTyCon other_tycon = False + tyConClass_maybe :: TyCon -> Maybe Class -tyConClass_maybe (DataTyCon _ _ _ _ _ _ _ maybe_cls _ _) = maybe_cls -tyConClass_maybe other_tycon = Nothing +tyConClass_maybe (AlgTyCon {algTyConClass = maybe_clas}) = maybe_clas +tyConClass_maybe ther_tycon = Nothing \end{code} -@derivedFor@ reports if we have an {\em obviously}-derived instance -for the given class/tycon. Of course, you might be deriving something -because it a superclass of some other obviously-derived class --- this -function doesn't deal with that. - -ToDo: what about derivings for specialised tycons !!! %************************************************************************ %* * @@ -324,25 +567,39 @@ instance Ord TyCon where a < b = case (a `compare` b) of { LT -> True; EQ -> False; GT -> False } a >= b = case (a `compare` b) of { LT -> False; EQ -> True; GT -> True } a > b = case (a `compare` b) of { LT -> False; EQ -> False; GT -> True } - compare a b = uniqueOf a `compare` uniqueOf b + compare a b = getUnique a `compare` getUnique b instance Uniquable TyCon where - uniqueOf tc = tyConUnique tc + getUnique tc = tyConUnique tc + +instance Outputable TyCon where + ppr tc = ppr (getName tc) + +instance NamedThing TyCon where + getName = tyConName \end{code} + +%************************************************************************ +%* * +\subsection{Kind constructors} +%* * +%************************************************************************ + +@matchesTyCon tc1 tc2@ checks whether an appliation +(tc1 t1..tn) matches (tc2 t1..tn). By "matches" we basically mean "equals", +except that at the kind level tc2 might have more boxity info than tc1. + \begin{code} -instance NamedThing TyCon where - getName (DataTyCon _ n _ _ _ _ _ _ _ _) = n - getName (PrimTyCon _ n _ _ _) = n - getName (SpecTyCon tc _) = getName tc - getName (SynTyCon _ n _ _ _ _) = n - getName FunTyCon = mkFunTyConName - getName (TupleTyCon _ n _) = n - -{- LATER: - getName (SpecTyCon tc tys) = let (OrigName m n) = origName "????" tc in - (m, n _APPEND_ specMaybeTysSuffix tys) - getName other_tc = moduleNamePair (expectJust "tycon1" (getName other_tc)) - getName other = Nothing --} +matchesTyCon :: TyCon -- Expected (e.g. arg type of function) + -> TyCon -- Inferred (e.g. type of actual arg to function) + -> Bool + +matchesTyCon tc1 tc2 = uniq1 == uniq2 || uniq1 == anyBoxConKey + where + uniq1 = tyConUnique tc1 + uniq2 = tyConUnique tc2 \end{code} + + +