X-Git-Url: http://git.megacz.com/?a=blobdiff_plain;f=ghc%2Fcompiler%2Ftypes%2FTyCon.lhs;h=fb969bc00463a6103ecdd310a631eb9c23e9f233;hb=ed4cd6d403d932026f38608f81c3a8872e38b2ce;hp=ada7c8d4b362d990b6ea8ce1584b9cb5d10ca7a9;hpb=38db229302890403037c5de7453299b3538bb404;p=ghc-hetmet.git diff --git a/ghc/compiler/types/TyCon.lhs b/ghc/compiler/types/TyCon.lhs index ada7c8d..fb969bc 100644 --- a/ghc/compiler/types/TyCon.lhs +++ b/ghc/compiler/types/TyCon.lhs @@ -1,26 +1,23 @@ % -% (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} -#include "HsVersions.h" - module TyCon( - TyCon(..), -- NB: some pals need to see representation + TyCon, KindCon, SuperKindCon, - SYN_IE(Arity), NewOrData(..), + isFunTyCon, isUnLiftedTyCon, isBoxedTyCon, isProductTyCon, + isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, isPrimTyCon, + isEnumerationTyCon, isTupleTyCon, isUnboxedTupleTyCon, - isFunTyCon, isPrimTyCon, isBoxedTyCon, - isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, maybeNewTyCon, - - mkDataTyCon, + mkAlgTyCon, mkFunTyCon, mkPrimTyCon, - mkSpecTyCon, mkTupleTyCon, - mkSynTyCon, + mkKindCon, + mkSuperKindCon, tyConKind, tyConUnique, @@ -30,280 +27,311 @@ module TyCon( tyConDerivings, tyConTheta, tyConPrimRep, - synTyConArity, + tyConArity, + tyConClass_maybe, getSynTyConDefn, maybeTyConSingleCon, - isEnumerationTyCon, isTupleTyCon, - derivedClasses + + matchesTyCon ) where -CHK_Ubiq() -- debugging consistency check - -#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ <= 201 -IMPORT_DELOOPER(TyLoop) ( SYN_IE(Type), GenType, - SYN_IE(Class), GenClass, - SYN_IE(Id), GenId, - splitSigmaTy, splitFunTy, - tupleCon, isNullaryDataCon, idType - --LATER: specMaybeTysSuffix - ) -#else -import {-# SOURCE #-} Type ( Type, splitSigmaTy, splitFunTy ) -import {-# SOURCE #-} Class ( Class ) -import {-# SOURCE #-} Id ( Id, isNullaryDataCon, idType ) -import {-# SOURCE #-} TysWiredIn ( tupleCon ) -#endif +#include "HsVersions.h" -import BasicTypes ( SYN_IE(Arity), NewOrData(..) ) -import TyVar ( GenTyVar, alphaTyVars, alphaTyVar, betaTyVar, SYN_IE(TyVar) ) -import Usage ( GenUsage, SYN_IE(Usage) ) -import Kind ( Kind, mkBoxedTypeKind, mkArrowKind, resultKind, argKind ) +import {-# SOURCE #-} Type ( Type, Kind, SuperKind ) +import {-# SOURCE #-} DataCon ( DataCon ) +import Class ( Class ) +import Var ( TyVar ) +import BasicTypes ( Arity, NewOrData(..), RecFlag(..) ) import Maybes -import Name ( Name, nameUnique, mkWiredInTyConName, NamedThing(getName) ) -import Unique ( Unique, funTyConKey, Uniquable(..) ) -import Pretty ( Doc ) -import PrimRep ( PrimRep(..) ) -import PrelMods ( gHC__, pREL_TUP, pREL_BASE ) -import Lex ( mkTupNameStr ) -import SrcLoc ( SrcLoc, mkBuiltinSrcLoc ) -import Util ( nOfThem, isIn, Ord3(..), panic, panic#, assertPanic ) +import Name ( Name, nameUnique, NamedThing(getName) ) +import Unique ( Unique, Uniquable(..), anyBoxConKey ) +import PrimRep ( PrimRep(..), isFollowableRep ) +import Outputable \end{code} -\begin{code} -data TyCon - = FunTyCon -- Kind = Type -> Type -> Type - - | DataTyCon Unique{-TyConKey-} - 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 - NewOrData - - | 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 unboxed; 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 - 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 gHC__ SLIT("->") FunTyCon - -mkSpecTyCon = SpecTyCon -mkTupleTyCon = TupleTyCon +type KindCon = TyCon +type SuperKindCon = TyCon -mkDataTyCon name = DataTyCon (nameUnique name) name -mkPrimTyCon name = PrimTyCon (nameUnique name) name -mkSynTyCon name = SynTyCon (nameUnique name) name - -isFunTyCon FunTyCon = True -isFunTyCon _ = False - -isPrimTyCon (PrimTyCon _ _ _ _) = True -isPrimTyCon _ = False +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], + dataTyConTheta :: [(Class,[Type])], + + dataCons :: [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 + + dataTyConDerivings :: [Class], -- Classes which have derived instances + + dataTyConClass_maybe :: (Maybe Class), -- Nothing for ordinary types; + -- Just c for the type constructor + -- for dictionaries of class c. + algTyConFlavour :: NewOrData, + algTyConRec :: RecFlag -- Tells whether the data type is part of + -- a mutually-recursive group or not + } + + | PrimTyCon { -- Primitive types; cannot be defined in Haskell + -- NB: All of these guys are *unlifted*, but not all are *unboxed* + tyConUnique :: Unique, + tyConName :: Name, + tyConKind :: Kind, + tyConArity :: Arity, + primTyConRep :: PrimRep + } + + | TupleTyCon { + + tyConUnique :: Unique, + tyConName :: Name, + tyConKind :: Kind, + tyConArity :: Arity, + tyConBoxed :: Bool, -- True for boxed; False for unboxed + tyConTyVars :: [TyVar], + dataCon :: DataCon + } + + | 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. + } + + | 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 + } +\end{code} --- At present there are no unboxed non-primitive types, so --- isBoxedTyCon is just the negation of isPrimTyCon. -isBoxedTyCon = not . isPrimTyCon +%************************************************************************ +%* * +\subsection{TyCon Construction} +%* * +%************************************************************************ --- 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 - -maybeNewTyCon :: TyCon -> Maybe ([TyVar], Type) -- Returns representation type info -maybeNewTyCon (DataTyCon _ _ _ _ _ (con:null_cons) _ NewType) - = ASSERT( null null_cons && null null_tys) - Just (tyvars, rep_ty) - where - (tyvars, theta, tau) = splitSigmaTy (idType con) - (rep_ty:null_tys, res_ty) = splitFunTy tau - -maybeNewTyCon other = Nothing - -isNewTyCon (DataTyCon _ _ _ _ _ _ _ NewType) = True -isNewTyCon other = False - -isSynTyCon (SynTyCon _ _ _ _ _ _) = True -isSynTyCon _ = False -\end{code} +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. \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 +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 + } + +mkAlgTyCon name kind tyvars theta cons derivs maybe_clas flavour rec + = AlgTyCon { + tyConName = name, + tyConUnique = nameUnique name, + tyConKind = kind, + tyConArity = length tyvars, + tyConTyVars = tyvars, + dataTyConTheta = theta, + dataCons = cons, + dataTyConDerivings = derivs, + dataTyConClass_maybe = maybe_clas, + algTyConFlavour = flavour, + algTyConRec = rec + } + +mkTupleTyCon name kind arity tyvars con boxed + = TupleTyCon { + tyConUnique = nameUnique name, + tyConName = name, + tyConKind = kind, + tyConArity = arity, + tyConBoxed = boxed, + tyConTyVars = tyvars, + dataCon = con + } + +mkPrimTyCon name kind arity rep + = PrimTyCon { + tyConName = name, + tyConUnique = nameUnique name, + tyConKind = kind, + tyConArity = arity, + primTyConRep = rep + } + +mkSynTyCon name kind arity tyvars rhs + = SynTyCon { + tyConName = name, + tyConUnique = nameUnique name, + tyConKind = kind, + tyConArity = arity, + tyConTyVars = tyvars, + synTyConDefn = rhs + } \end{code} \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" - -synTyConArity :: TyCon -> Maybe Arity -- Nothing <=> not a syn tycon -synTyConArity (SynTyCon _ _ _ arity _ _) = Just arity -synTyConArity _ = Nothing -\end{code} +isFunTyCon (FunTyCon {}) = True +isFunTyCon _ = False -\begin{code} -tyConTyVars :: TyCon -> [TyVar] -tyConTyVars FunTyCon = [alphaTyVar,betaTyVar] -tyConTyVars (DataTyCon _ _ _ tvs _ _ _ _) = tvs -tyConTyVars (TupleTyCon _ _ arity) = take arity alphaTyVars -tyConTyVars (SynTyCon _ _ _ _ tvs _) = tvs -#ifdef DEBUG -tyConTyVars (PrimTyCon _ _ _ _) = panic "tyConTyVars:PrimTyCon" -tyConTyVars (SpecTyCon _ _ ) = panic "tyConTyVars:SpecTyCon" -#endif +isPrimTyCon (PrimTyCon {}) = True +isPrimTyCon _ = False + +isUnLiftedTyCon (PrimTyCon {}) = True +isUnLiftedTyCon (TupleTyCon { tyConBoxed = False }) = True +isUnLiftedTyCon _ = False + +-- isBoxedTyCon should not be applied to SynTyCon, nor KindCon +isBoxedTyCon (AlgTyCon {}) = True +isBoxedTyCon (FunTyCon {}) = True +isBoxedTyCon (TupleTyCon {tyConBoxed = boxed}) = boxed +isBoxedTyCon (PrimTyCon {primTyConRep = rep}) = isFollowableRep rep + +-- isAlgTyCon returns True for both @data@ and @newtype@ +isAlgTyCon (AlgTyCon {}) = True +isAlgTyCon (TupleTyCon {}) = True +isAlgTyCon other = False + +-- isDataTyCon returns False for @newtype@ and for unboxed tuples +isDataTyCon (AlgTyCon {algTyConFlavour = new_or_data}) = case new_or_data of + NewType -> False + other -> True +isDataTyCon (TupleTyCon {tyConBoxed = True}) = True +isDataTyCon other = False + +isNewTyCon (AlgTyCon {algTyConFlavour = NewType}) = True +isNewTyCon other = False + +-- A "product" tycon is non-recursive and has one constructor, +-- whether DataType or NewType +isProductTyCon (AlgTyCon {dataCons = [c], algTyConRec = NonRecursive}) = True +isProductTyCon (TupleTyCon {}) = True +isProductTyCon other = False + +isSynTyCon (SynTyCon {}) = True +isSynTyCon _ = False + +isEnumerationTyCon (AlgTyCon {algTyConFlavour = EnumType}) = True +isEnumerationTyCon other = False + +-- The unit tycon isn't classed as a tuple tycon +isTupleTyCon (TupleTyCon {tyConArity = arity, tyConBoxed = True}) = arity >= 2 +isTupleTyCon other = False + +isUnboxedTupleTyCon (TupleTyCon {tyConBoxed = False}) = True +isUnboxedTupleTyCon other = False \end{code} \begin{code} -tyConDataCons :: TyCon -> [Id] -tyConFamilySize :: TyCon -> Int - -tyConDataCons (DataTyCon _ _ _ _ _ data_cons _ _) = data_cons -tyConDataCons (TupleTyCon _ _ a) = [tupleCon a] -tyConDataCons other = [] +tyConDataCons :: TyCon -> [DataCon] +tyConDataCons (AlgTyCon {dataCons = cons}) = cons +tyConDataCons (TupleTyCon {dataCon = con}) = [con] +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 +tyConFamilySize :: TyCon -> Int +tyConFamilySize (AlgTyCon {dataCons = cons}) = length cons +tyConFamilySize (TupleTyCon {}) = 1 #ifdef DEBUG ---tyConFamilySize other = pprPanic "tyConFamilySize:" (pprTyCon PprDebug other) +tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other) #endif tyConPrimRep :: TyCon -> PrimRep -tyConPrimRep (PrimTyCon _ _ _ rep) = rep -tyConPrimRep _ = PtrRep +tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep +tyConPrimRep _ = PtrRep \end{code} \begin{code} tyConDerivings :: TyCon -> [Class] -tyConDerivings (DataTyCon _ _ _ _ _ _ derivs _) = derivs -tyConDerivings other = [] +tyConDerivings (AlgTyCon {dataTyConDerivings = derivs}) = derivs +tyConDerivings other = [] \end{code} \begin{code} -tyConTheta :: TyCon -> [(Class,Type)] -tyConTheta (DataTyCon _ _ _ _ theta _ _ _) = theta -tyConTheta (TupleTyCon _ _ _) = [] +tyConTheta :: TyCon -> [(Class, [Type])] +tyConTheta (AlgTyCon {dataTyConTheta = theta}) = theta -- should ask about anything else \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 - -isEnumerationTyCon (TupleTyCon _ _ arity) - = arity == 0 -isEnumerationTyCon (DataTyCon _ _ _ _ _ data_cons _ _) - = not (null data_cons) && all isNullaryDataCon data_cons - - -isTupleTyCon (TupleTyCon _ _ arity) = arity >= 2 -- treat "0-tuple" specially -isTupleTyCon (SpecTyCon tc tys) = isTupleTyCon tc -isTupleTyCon other = False - - +maybeTyConSingleCon :: TyCon -> Maybe DataCon +maybeTyConSingleCon (AlgTyCon {dataCons = [c]}) = Just c +maybeTyConSingleCon (AlgTyCon {}) = Nothing +maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con +maybeTyConSingleCon (PrimTyCon {}) = Nothing +maybeTyConSingleCon other = panic (showSDoc (ppr other)) \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 !!! - \begin{code} -derivedClasses :: TyCon -> [Class] -derivedClasses (DataTyCon _ _ _ _ _ _ derivs _) = derivs -derivedClasses something_weird = [] +tyConClass_maybe :: TyCon -> Maybe Class +tyConClass_maybe (AlgTyCon {dataTyConClass_maybe = maybe_cls}) = maybe_cls +tyConClass_maybe other_tycon = Nothing \end{code} + %************************************************************************ %* * \subsection[TyCon-instances]{Instance declarations for @TyCon@} @@ -316,44 +344,45 @@ The strictness analyser needs @Ord@. It is a lexicographic order with the property @(a<=b) || (b<=a)@. \begin{code} -instance Ord3 TyCon where - cmp tc1 tc2 = uniqueOf tc1 `cmp` uniqueOf tc2 - instance Eq TyCon where - a == b = case (a `cmp` b) of { EQ_ -> True; _ -> False } - a /= b = case (a `cmp` b) of { EQ_ -> False; _ -> True } + a == b = case (a `compare` b) of { EQ -> True; _ -> False } + a /= b = case (a `compare` b) of { EQ -> False; _ -> True } instance Ord TyCon where - a <= b = case (a `cmp` b) of { LT_ -> True; EQ_ -> True; GT__ -> False } - a < b = case (a `cmp` b) of { LT_ -> True; EQ_ -> False; GT__ -> False } - a >= b = case (a `cmp` b) of { LT_ -> False; EQ_ -> True; GT__ -> True } - a > b = case (a `cmp` b) of { LT_ -> False; EQ_ -> False; GT__ -> True } - _tagCmp a b = case (a `cmp` b) of { LT_ -> _LT; EQ_ -> _EQ; GT__ -> _GT } + a <= b = case (a `compare` b) of { LT -> True; EQ -> True; GT -> False } + 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 = getUnique a `compare` getUnique b instance Uniquable TyCon where - uniqueOf (DataTyCon u _ _ _ _ _ _ _) = u - uniqueOf (TupleTyCon u _ _) = u - uniqueOf (PrimTyCon u _ _ _) = u - uniqueOf (SynTyCon u _ _ _ _ _) = u - uniqueOf tc@(SpecTyCon _ _) = panic "uniqueOf:SpecTyCon" - uniqueOf tc = uniqueOf (getName tc) -\end{code} + getUnique tc = tyConUnique tc + +instance Outputable TyCon where + ppr tc = ppr (getName tc) -\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 - getName tc = panic "TyCon.getName" - -{- 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 --} + 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} +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}