%
-% (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
-
- Arity(..), NewOrData(..),
+ TyCon, KindCon, SuperKindCon,
- isFunTyCon, isPrimTyCon, isBoxedTyCon,
- isDataTyCon, isSynTyCon,
+ isFunTyCon, isUnLiftedTyCon, isBoxedTyCon, isProductTyCon,
+ isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, isPrimTyCon,
+ isEnumerationTyCon, isTupleTyCon, isUnboxedTupleTyCon,
- mkDataTyCon,
+ mkAlgTyCon,
mkFunTyCon,
mkPrimTyCon,
- mkSpecTyCon,
mkTupleTyCon,
-
mkSynTyCon,
+ mkKindCon,
+ mkSuperKindCon,
tyConKind,
tyConUnique,
tyConDataCons,
tyConFamilySize,
tyConDerivings,
- tyConArity, synTyConArity,
+ tyConTheta,
+ tyConPrimRep,
+ tyConArity,
+ tyConClass_maybe,
getSynTyConDefn,
maybeTyConSingleCon,
- isEnumerationTyCon,
- derivedFor
-) where
-CHK_Ubiq() -- debugging consistency check
-import NameLoop -- for paranoia checking
+ matchesTyCon
+) where
-import TyLoop ( Type(..), GenType,
- Class(..), GenClass,
- Id(..), GenId,
- mkTupleCon, dataConSig,
- specMaybeTysSuffix
- )
+#include "HsVersions.h"
-import TyVar ( GenTyVar, alphaTyVars, alphaTyVar, betaTyVar )
-import Usage ( GenUsage, Usage(..) )
-import Kind ( Kind, mkBoxedTypeKind, mkArrowKind, resultKind, argKind )
-import PrelMods ( pRELUDE_BUILTIN )
+import {-# SOURCE #-} Type ( Type, Kind, SuperKind )
+import {-# SOURCE #-} DataCon ( DataCon )
+import Class ( Class )
+import Var ( TyVar )
+import BasicTypes ( Arity, NewOrData(..), RecFlag(..) )
import Maybes
-import NameTypes ( FullName )
-import Unique ( Unique, funTyConKey, mkTupleTyConUnique )
+import Name ( Name, nameUnique, NamedThing(getName) )
+import Unique ( Unique, Uniquable(..), anyBoxConKey )
+import PrimRep ( PrimRep(..), isFollowableRep )
import Outputable
-import Pretty ( Pretty(..), PrettyRep )
-import PprStyle ( PprStyle )
-import SrcLoc ( SrcLoc, mkBuiltinSrcLoc )
-import Util ( panic, panic#, nOfThem, isIn, Ord3(..) )
\end{code}
+%************************************************************************
+%* *
+\subsection{The data type}
+%* *
+%************************************************************************
+
\begin{code}
-type Arity = Int
+type KindCon = TyCon
+type SuperKindCon = TyCon
data TyCon
- = FunTyCon -- Kind = Type -> Type -> Type
-
- | DataTyCon Unique{-TyConKey-}
- Kind
- FullName
- [TyVar]
- [(Class,Type)] -- Its context
- [Id] -- Its data constructors, with fully polymorphic types
- [Class] -- Classes which have derived instances
- NewOrData
-
- | TupleTyCon 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
- FullName -- Often represented by a bit-pattern for the thing
- Kind -- itself (eg Int#), but sometimes by a pointer to
-
- | 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
- FullName
- 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.
-
-data NewOrData
- = NewType -- "newtype Blah ..."
- | DataType -- "data Blah ..."
+ = 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}
-\begin{code}
-mkFunTyCon = FunTyCon
-mkDataTyCon = DataTyCon
-mkTupleTyCon = TupleTyCon
-mkPrimTyCon = PrimTyCon
-mkSpecTyCon = SpecTyCon
-mkSynTyCon = SynTyCon
-
-isFunTyCon FunTyCon = True
-isFunTyCon _ = False
-
-isPrimTyCon (PrimTyCon _ _ _) = True
-isPrimTyCon _ = False
-
--- At present there are no unboxed non-primitive types, so
--- isBoxedTyCon is just the negation of isPrimTyCon.
-isBoxedTyCon = not . isPrimTyCon
-
--- isDataTyCon returns False for @newtype@.
--- Not sure about this decision yet.
-isDataTyCon (DataTyCon _ _ _ _ _ _ _ DataType) = True
-isDataTyCon other = False
-
-isSynTyCon (SynTyCon _ _ _ _ _ _) = True
-isSynTyCon _ = False
-\end{code}
+%************************************************************************
+%* *
+\subsection{TyCon Construction}
+%* *
+%************************************************************************
-\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 (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
-
-tyConKind (TupleTyCon n)
- = mkArrow n
- where
- mkArrow 0 = mkBoxedTypeKind
- mkArrow 1 = kind1
- mkArrow 2 = kind2
- mkArrow n = mkBoxedTypeKind `mkArrowKind` mkArrow (n-1)
-\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}
-tyConUnique :: TyCon -> Unique
-tyConUnique FunTyCon = funTyConKey
-tyConUnique (DataTyCon uniq _ _ _ _ _ _ _) = uniq
-tyConUnique (TupleTyCon a) = mkTupleTyConUnique a
-tyConUnique (PrimTyCon uniq _ _) = uniq
-tyConUnique (SynTyCon uniq _ _ _ _ _) = uniq
-tyConUnique (SpecTyCon _ _ ) = panic "tyConUnique:SpecTyCon"
-
-tyConArity :: TyCon -> Arity
-tyConArity FunTyCon = 2
-tyConArity (DataTyCon _ _ _ tvs _ _ _ _) = length tvs
-tyConArity (TupleTyCon arity) = arity
-tyConArity (PrimTyCon _ _ _) = 0 -- ??
-tyConArity (SpecTyCon _ _) = 0
-tyConArity (SynTyCon _ _ _ arity _ _) = arity
-
-synTyConArity :: TyCon -> Maybe Arity -- Nothing <=> not a syn tycon
-synTyConArity (SynTyCon _ _ _ arity _ _) = Just arity
-synTyConArity _ = Nothing
+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}
-tyConTyVars :: TyCon -> [TyVar]
-tyConTyVars FunTyCon = [alphaTyVar,betaTyVar]
-tyConTyVars (DataTyCon _ _ _ tvs _ _ _ _) = tvs
-tyConTyVars (TupleTyCon arity) = take arity alphaTyVars
-tyConTyVars (SynTyCon _ _ _ _ tvs _) = tvs
-tyConTyVars (PrimTyCon _ _ _) = panic "tyConTyVars:PrimTyCon"
-tyConTyVars (SpecTyCon _ _ ) = panic "tyConTyVars:SpecTyCon"
+isFunTyCon (FunTyCon {}) = True
+isFunTyCon _ = False
+
+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) = [mkTupleCon 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 a) = 1
+tyConFamilySize :: TyCon -> Int
+tyConFamilySize (AlgTyCon {dataCons = cons}) = length cons
+tyConFamilySize (TupleTyCon {}) = 1
+#ifdef DEBUG
+tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
+#endif
+
+tyConPrimRep :: TyCon -> PrimRep
+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}
-getSynTyConDefn :: TyCon -> ([TyVar], Type)
-getSynTyConDefn (SynTyCon _ _ _ _ tyvars ty) = (tyvars,ty)
+tyConTheta :: TyCon -> [(Class, [Type])]
+tyConTheta (AlgTyCon {dataTyConTheta = theta}) = theta
+-- should ask about anything else
\end{code}
\begin{code}
-maybeTyConSingleCon :: TyCon -> Maybe Id
-maybeTyConSingleCon (TupleTyCon arity) = Just (mkTupleCon 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 is_nullary data_cons
- where
- is_nullary con = case (dataConSig con) of { (_,_, arg_tys, _) ->
- null arg_tys }
+getSynTyConDefn :: TyCon -> ([TyVar], Type)
+getSynTyConDefn (SynTyCon {tyConTyVars = tyvars, synTyConDefn = ty}) = (tyvars,ty)
\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}
+maybeTyConSingleCon :: TyCon -> Maybe DataCon
+maybeTyConSingleCon (AlgTyCon {dataCons = [c]}) = Just c
+maybeTyConSingleCon (AlgTyCon {}) = Nothing
+maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con
+maybeTyConSingleCon (PrimTyCon {}) = Nothing
+\end{code}
\begin{code}
-derivedFor :: Class -> TyCon -> Bool
-derivedFor clas (DataTyCon _ _ _ _ _ _ derivs _) = isIn "derivedFor" clas derivs
-derivedFor clas something_weird = False
+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@}
the property @(a<=b) || (b<=a)@.
\begin{code}
-instance Ord3 TyCon where
- cmp FunTyCon FunTyCon = EQ_
- cmp (DataTyCon a _ _ _ _ _ _ _) (DataTyCon b _ _ _ _ _ _ _) = a `cmp` b
- cmp (SynTyCon a _ _ _ _ _) (SynTyCon b _ _ _ _ _) = a `cmp` b
- cmp (TupleTyCon a) (TupleTyCon b) = a `cmp` b
- cmp (PrimTyCon a _ _) (PrimTyCon b _ _) = a `cmp` b
- cmp (SpecTyCon tc1 mtys1) (SpecTyCon tc2 mtys2)
- = panic# "cmp on SpecTyCons" -- case (tc1 `cmp` tc2) of { EQ_ -> mtys1 `cmp` mtys2; xxx -> xxx }
-
- -- now we *know* the tags are different, so...
- cmp other_1 other_2
- | tag1 _LT_ tag2 = LT_
- | otherwise = GT_
- where
- tag1 = tag_TyCon other_1
- tag2 = tag_TyCon other_2
- tag_TyCon FunTyCon = ILIT(1)
- tag_TyCon (DataTyCon _ _ _ _ _ _ _ _) = ILIT(2)
- tag_TyCon (TupleTyCon _) = ILIT(3)
- tag_TyCon (PrimTyCon _ _ _) = ILIT(4)
- tag_TyCon (SpecTyCon _ _) = ILIT(5)
-
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 }
-\end{code}
-
-\begin{code}
-instance NamedThing TyCon where
- getExportFlag tc = case get_name tc of
- Nothing -> NotExported
- Just name -> getExportFlag name
-
-
- isLocallyDefined tc = case get_name tc of
- Nothing -> False
- Just name -> isLocallyDefined name
+ 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
- getOrigName FunTyCon = (pRELUDE_BUILTIN, SLIT("(->)"))
- getOrigName (TupleTyCon a) = (pRELUDE_BUILTIN, _PK_ ("Tuple" ++ show a))
- getOrigName (SpecTyCon tc tys) = let (m,n) = getOrigName tc in
- (m, n _APPEND_ specMaybeTysSuffix tys)
- getOrigName other_tc = getOrigName (expectJust "tycon1" (get_name other_tc))
+instance Uniquable TyCon where
+ getUnique tc = tyConUnique tc
- getOccurrenceName FunTyCon = SLIT("(->)")
- getOccurrenceName (TupleTyCon 0) = SLIT("()")
- getOccurrenceName (TupleTyCon a) = _PK_ ( "(" ++ nOfThem (a-1) ',' ++ ")" )
- getOccurrenceName (SpecTyCon tc tys)= getOccurrenceName tc _APPEND_ specMaybeTysSuffix tys
- getOccurrenceName other_tc = getOccurrenceName (expectJust "tycon2" (get_name other_tc))
+instance Outputable TyCon where
+ ppr tc = ppr (getName tc)
- getInformingModules tc = case get_name tc of
- Nothing -> panic "getInformingModule:TyCon"
- Just name -> getInformingModules name
-
- getSrcLoc tc = case get_name tc of
- Nothing -> mkBuiltinSrcLoc
- Just name -> getSrcLoc name
+instance NamedThing TyCon where
+ getName = tyConName
+\end{code}
- getItsUnique tycon = tyConUnique tycon
- fromPreludeCore tc = case get_name tc of
- Nothing -> True
- Just name -> fromPreludeCore name
-\end{code}
+%************************************************************************
+%* *
+\subsection{Kind constructors}
+%* *
+%************************************************************************
-Emphatically un-exported:
+@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}
-get_name (DataTyCon _ _ n _ _ _ _ _) = Just n
-get_name (PrimTyCon _ n _) = Just n
-get_name (SpecTyCon tc _) = get_name tc
-get_name (SynTyCon _ n _ _ _ _) = Just n
-get_name 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}