\begin{code}
module TyCon(
- TyCon, KindCon, Boxity(..),
+ TyCon, ArgVrcs,
- isFunTyCon, isUnLiftedTyCon, isBoxedTyCon, isProductTyCon,
+ PrimRep(..),
+ tyConPrimRep,
+
+ AlgTyConRhs(..), visibleDataCons,
+
+ isFunTyCon, isUnLiftedTyCon, isProductTyCon, isAbstractTyCon,
isAlgTyCon, isDataTyCon, isSynTyCon, isNewTyCon, isPrimTyCon,
- isEnumerationTyCon, isTupleTyCon, isUnboxedTupleTyCon,
+ isEnumerationTyCon,
+ isTupleTyCon, isUnboxedTupleTyCon, isBoxedTupleTyCon, tupleTyConBoxity,
+ isRecursiveTyCon, newTyConRep, newTyConRhs, isHiBootTyCon,
+
+ mkForeignTyCon, isForeignTyCon,
mkAlgTyCon,
+ mkClassTyCon,
mkFunTyCon,
mkPrimTyCon,
+ mkLiftedPrimTyCon,
mkTupleTyCon,
mkSynTyCon,
- mkKindCon,
- superKindCon,
+ tyConName,
tyConKind,
tyConUnique,
tyConTyVars,
- tyConDataCons,
- tyConFamilySize,
- tyConDerivings,
+ tyConArgVrcs,
+ algTyConRhs, tyConDataCons, tyConDataCons_maybe, tyConFamilySize,
+ tyConSelIds,
tyConTheta,
- tyConPrimRep,
tyConArity,
- tyConClass_maybe,
+ isClassTyCon, tyConClass_maybe,
getSynTyConDefn,
+ tyConExtName, -- External name for foreign types
maybeTyConSingleCon,
- matchesTyCon
+ -- Generics
+ tyConHasGenerics
) where
#include "HsVersions.h"
-import {-# SOURCE #-} Type ( Type, Kind )
-import {-# SOURCE #-} DataCon ( DataCon )
+import {-# SOURCE #-} TypeRep ( Type, PredType )
+ -- 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 Class ( Class )
-import Var ( TyVar )
-import BasicTypes ( Arity, NewOrData(..), RecFlag(..) )
-import Maybes
+
+import Var ( TyVar, Id )
+import Class ( Class )
+import Kind ( Kind )
+import BasicTypes ( Arity, RecFlag(..), Boxity(..), isBoxed )
import Name ( Name, nameUnique, NamedThing(getName) )
-import Unique ( Unique, Uniquable(..), superKindConKey )
-import PrimRep ( PrimRep(..), isFollowableRep )
+import PrelNames ( Unique, Uniquable(..) )
+import Maybes ( orElse )
import Outputable
+import FastString
\end{code}
%************************************************************************
%************************************************************************
\begin{code}
-type KindCon = TyCon
-
data TyCon
= FunTyCon {
tyConUnique :: Unique,
}
- | AlgTyCon { -- Tuples, data type, and newtype decls.
+ | AlgTyCon { -- 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
+ tyConTyVars :: [TyVar],
+ argVrcs :: ArgVrcs,
+ algTyConTheta :: [PredType],
+
+ selIds :: [Id], -- Its record selectors (if any)
+
+ algRhs :: AlgTyConRhs, -- Data constructors in here
+
+ algTyConRec :: RecFlag, -- Tells whether the data type is part of
+ -- a mutually-recursive group or not
+
+ hasGenerics :: Bool, -- True <=> generic to/from functions are available
+ -- (in the exports of the data type's source module)
+
+ algTyConClass :: Maybe Class
+ -- Just cl if this tycon came from a class declaration
}
- | 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
+ | PrimTyCon { -- Primitive types; cannot be defined in Haskell
+ -- Now includes foreign-imported types
+ tyConUnique :: Unique,
+ tyConName :: Name,
+ tyConKind :: Kind,
+ tyConArity :: Arity,
+ argVrcs :: ArgVrcs,
+
+ primTyConRep :: PrimRep,
+ -- Many primitive tycons are unboxed, but some are
+ -- boxed (represented by pointers). The CgRep tells.
+
+ isUnLifted :: Bool, -- Most primitive tycons are unlifted,
+ -- but foreign-imported ones may not be
+ tyConExtName :: Maybe FastString -- Just xx for foreign-imported types
}
| TupleTyCon {
-
tyConUnique :: Unique,
tyConName :: Name,
tyConKind :: Kind,
tyConArity :: Arity,
- tyConBoxed :: Bool,
+ tyConBoxed :: Boxity,
tyConTyVars :: [TyVar],
- dataCon :: DataCon
+ dataCon :: DataCon,
+ hasGenerics :: Bool
}
| SynTyCon {
tyConKind :: Kind,
tyConArity :: Arity,
- tyConTyVars :: [TyVar], -- Bound tyvars
- synTyConDefn :: Type -- Right-hand side, mentioning these type vars.
+ 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.
+ argVrcs :: ArgVrcs
}
- | KindCon { -- Type constructor at the kind level
- tyConUnique :: Unique,
- tyConName :: Name,
- tyConKind :: Kind,
- tyConArity :: Arity,
-
- kindConBoxity :: Boxity
- }
+type ArgVrcs = [(Bool,Bool)] -- Tyvar variance info: [(occPos,occNeg)]
+ -- [] means "no information, assume the worst"
+
+data AlgTyConRhs
+ = AbstractTyCon -- We know nothing about this data type, except
+ -- that it's represented by a pointer
+ -- Used when we export a data type abstractly into
+ -- an hi file
+
+ | DataTyCon
+ [DataCon] -- The constructors; can be empty if the user declares
+ -- the type to have no constructors
+ Bool -- Cached: True <=> an enumeration type
+
+ | NewTyCon -- Newtypes always have exactly one constructor
+ DataCon -- The unique constructor; it has no existentials
+ Type -- Cached: the argument type of the constructor
+ -- = the representation type of the tycon
+
+ Type -- Cached: the *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.
+
+visibleDataCons :: AlgTyConRhs -> [DataCon]
+visibleDataCons AbstractTyCon = []
+visibleDataCons (DataTyCon cs _) = cs
+visibleDataCons (NewTyCon c _ _) = [c]
+\end{code}
- | SuperKindCon { -- The type of kind variables,
- tyConUnique :: Unique -- sometimes written as a box
- }
+%************************************************************************
+%* *
+\subsection{PrimRep}
+%* *
+%************************************************************************
+
+A PrimRep is an abstraction of a type. It contains information that
+the code generator needs in order to pass arguments, return results,
+and store values of this type.
+
+A PrimRep is somewhat similar to a CgRep (see codeGen/SMRep) and a
+MachRep (see cmm/MachOp), although each of these types has a distinct
+and clearly defined purpose:
+
+ - A PrimRep is a CgRep + information about signedness + information
+ about primitive pointers (AddrRep). Signedness and primitive
+ pointers are required when passing a primitive type to a foreign
+ function, but aren't needed for call/return conventions of Haskell
+ functions.
-data Boxity = Boxed | Unboxed | Open
+ - A MachRep is a basic machine type (non-void, doesn't contain
+ information on pointerhood or signedness, but contains some
+ reps that don't have corresponding Haskell types).
+
+\begin{code}
+data PrimRep
+ = VoidRep
+ | PtrRep
+ | IntRep -- signed, word-sized
+ | WordRep -- unsinged, word-sized
+ | Int64Rep -- signed, 64 bit (32-bit words only)
+ | Word64Rep -- unsigned, 64 bit (32-bit words only)
+ | AddrRep -- a pointer, but not to a Haskell value
+ | FloatRep
+ | DoubleRep
\end{code}
%************************************************************************
So we compromise, and move their Kind calculation to the call site.
\begin{code}
-superKindCon = SuperKindCon superKindConKey
-
-mkKindCon name kind boxity
- = KindCon {
- tyConUnique = nameUnique name,
- tyConName = name,
- tyConArity = 0,
- tyConKind = kind,
- kindConBoxity = boxity
- }
-
+mkFunTyCon :: Name -> Kind -> TyCon
mkFunTyCon name kind
= FunTyCon {
tyConUnique = nameUnique name,
tyConKind = kind,
tyConArity = 2
}
-
-mkAlgTyCon name kind tyvars theta cons derivs maybe_clas flavour rec
+
+-- 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 rhs sels is_rec gen_info
= 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
+ tyConName = name,
+ tyConUnique = nameUnique name,
+ tyConKind = kind,
+ tyConArity = length tyvars,
+ tyConTyVars = tyvars,
+ argVrcs = argvrcs,
+ algTyConTheta = theta,
+ algRhs = rhs,
+ selIds = sels,
+ algTyConClass = Nothing,
+ algTyConRec = is_rec,
+ hasGenerics = gen_info
+ }
+
+mkClassTyCon name kind tyvars argvrcs rhs clas is_rec
+ = AlgTyCon {
+ tyConName = name,
+ tyConUnique = nameUnique name,
+ tyConKind = kind,
+ tyConArity = length tyvars,
+ tyConTyVars = tyvars,
+ argVrcs = argvrcs,
+ algTyConTheta = [],
+ algRhs = rhs,
+ selIds = [],
+ algTyConClass = Just clas,
+ algTyConRec = is_rec,
+ hasGenerics = False
}
-mkTupleTyCon name kind arity tyvars con boxed
+
+mkTupleTyCon name kind arity tyvars con boxed gen_info
= TupleTyCon {
tyConUnique = nameUnique name,
tyConName = name,
tyConArity = arity,
tyConBoxed = boxed,
tyConTyVars = tyvars,
- dataCon = con
+ dataCon = con,
+ hasGenerics = gen_info
}
-mkPrimTyCon name kind arity rep
+-- 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<T>
+mkForeignTyCon name ext_name kind arity arg_vrcs
= PrimTyCon {
- tyConName = name,
- tyConUnique = nameUnique name,
- tyConKind = kind,
- tyConArity = arity,
- primTyConRep = rep
+ tyConName = name,
+ tyConUnique = nameUnique name,
+ tyConKind = kind,
+ tyConArity = arity,
+ argVrcs = arg_vrcs,
+ primTyConRep = PtrRep, -- they all do
+ 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,
+ argVrcs = arg_vrcs,
+ primTyConRep = rep,
+ isUnLifted = is_unlifted,
+ tyConExtName = Nothing
}
-mkSynTyCon name kind arity tyvars rhs
+mkSynTyCon name kind tyvars rhs argvrcs
= SynTyCon {
tyConName = name,
tyConUnique = nameUnique name,
tyConKind = kind,
- tyConArity = arity,
+ tyConArity = length tyvars,
tyConTyVars = tyvars,
- synTyConDefn = rhs
+ synTyConDefn = rhs,
+ argVrcs = argvrcs
}
\end{code}
\begin{code}
+isFunTyCon :: TyCon -> Bool
isFunTyCon (FunTyCon {}) = True
isFunTyCon _ = False
+isAbstractTyCon :: TyCon -> Bool
+isAbstractTyCon (AlgTyCon { algRhs = AbstractTyCon }) = True
+isAbstractTyCon _ = False
+
+isPrimTyCon :: TyCon -> Bool
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
+isUnLiftedTyCon :: TyCon -> Bool
+isUnLiftedTyCon (PrimTyCon {isUnLifted = is_unlifted}) = is_unlifted
+isUnLiftedTyCon (TupleTyCon {tyConBoxed = boxity}) = not (isBoxed boxity)
+isUnLiftedTyCon _ = False
-- isAlgTyCon returns True for both @data@ and @newtype@
+isAlgTyCon :: TyCon -> Bool
isAlgTyCon (AlgTyCon {}) = True
isAlgTyCon (TupleTyCon {}) = True
isAlgTyCon other = False
--- isDataTyCon returns False for @newtype@.
-isDataTyCon (AlgTyCon {algTyConFlavour = new_or_data}) = case new_or_data of
- NewType -> False
- other -> True
-isDataTyCon (TupleTyCon {}) = True -- is an unboxed tuple a datatype?
+algTyConRhs :: TyCon -> AlgTyConRhs
+algTyConRhs (AlgTyCon {algRhs = rhs}) = rhs
+algTyConRhs (TupleTyCon {dataCon = dc}) = DataTyCon [dc] 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 {algRhs = rhs})
+ = case rhs of
+ DataTyCon _ _ -> True
+ NewTyCon _ _ _ -> False
+ AbstractTyCon -> panic "isDataTyCon"
+
+isDataTyCon (TupleTyCon {tyConBoxed = boxity}) = isBoxed boxity
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
-
+isNewTyCon :: TyCon -> Bool
+isNewTyCon (AlgTyCon {algRhs = 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 tc@(AlgTyCon {}) = case algRhs tc of
+ DataTyCon [data_con] _ -> not (isExistentialDataCon data_con)
+ NewTyCon _ _ _ -> True
+ other -> False
+isProductTyCon (TupleTyCon {}) = True
+isProductTyCon other = False
+
+isSynTyCon :: TyCon -> Bool
isSynTyCon (SynTyCon {}) = True
isSynTyCon _ = False
-isEnumerationTyCon (AlgTyCon {algTyConFlavour = EnumType}) = True
-isEnumerationTyCon other = False
+isEnumerationTyCon :: TyCon -> Bool
+isEnumerationTyCon (AlgTyCon {algRhs = DataTyCon _ is_enum}) = is_enum
+isEnumerationTyCon other = False
--- The unit tycon isn't classed as a tuple tycon
-isTupleTyCon (TupleTyCon {tyConArity = arity, tyConBoxed = True}) = arity >= 2
-isTupleTyCon 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 (TupleTyCon {tyConBoxed = False}) = True
+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
+
+isHiBootTyCon :: TyCon -> Bool
+-- Used for knot-tying in hi-boot files
+isHiBootTyCon (AlgTyCon {algRhs = AbstractTyCon}) = True
+isHiBootTyCon other = False
+
+isForeignTyCon :: TyCon -> Bool
+-- isForeignTyCon identifies foreign-imported type constructors
+isForeignTyCon (PrimTyCon {tyConExtName = Just _}) = True
+isForeignTyCon other = False
\end{code}
\begin{code}
+tyConHasGenerics :: TyCon -> Bool
+tyConHasGenerics (AlgTyCon {hasGenerics = hg}) = hg
+tyConHasGenerics (TupleTyCon {hasGenerics = hg}) = hg
+tyConHasGenerics other = False -- Synonyms
+
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.
+-- It's convenient for tyConDataCons to return the
+-- empty list for type synonyms etc
+tyConDataCons tycon = tyConDataCons_maybe tycon `orElse` []
+
+tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
+tyConDataCons_maybe (AlgTyCon {algRhs = DataTyCon cons _}) = Just cons
+tyConDataCons_maybe (AlgTyCon {algRhs = NewTyCon con _ _}) = Just [con]
+tyConDataCons_maybe (TupleTyCon {dataCon = con}) = Just [con]
+tyConDataCons_maybe other = Nothing
tyConFamilySize :: TyCon -> Int
-tyConFamilySize (AlgTyCon {dataCons = cons}) = length cons
-tyConFamilySize (TupleTyCon {}) = 1
+tyConFamilySize (AlgTyCon {algRhs = DataTyCon cons _}) = length cons
+tyConFamilySize (AlgTyCon {algRhs = NewTyCon _ _ _}) = 1
+tyConFamilySize (TupleTyCon {}) = 1
#ifdef DEBUG
tyConFamilySize other = pprPanic "tyConFamilySize:" (ppr other)
#endif
+tyConSelIds :: TyCon -> [Id]
+tyConSelIds (AlgTyCon {selIds = sels}) = sels
+tyConSelIds other_tycon = []
+\end{code}
+
+\begin{code}
+newTyConRep :: TyCon -> ([TyVar], Type)
+newTyConRep (AlgTyCon {tyConTyVars = tvs, algRhs = NewTyCon _ _ rep}) = (tvs, rep)
+
+newTyConRhs :: TyCon -> ([TyVar], Type)
+newTyConRhs (AlgTyCon {tyConTyVars = tvs, algRhs = NewTyCon _ rhs _}) = (tvs, rhs)
+\end{code}
+
+\begin{code}
tyConPrimRep :: TyCon -> PrimRep
tyConPrimRep (PrimTyCon {primTyConRep = rep}) = rep
-tyConPrimRep _ = PtrRep
+tyConPrimRep tc = ASSERT(not (isUnboxedTupleTyCon tc)) PtrRep
\end{code}
\begin{code}
-tyConDerivings :: TyCon -> [Class]
-tyConDerivings (AlgTyCon {dataTyConDerivings = 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 (AlgTyCon {dataTyConTheta = theta}) = theta
--- should ask about anything else
+tyConArgVrcs :: TyCon -> ArgVrcs
+tyConArgVrcs (FunTyCon {}) = [(False,True),(True,False)]
+tyConArgVrcs (AlgTyCon {argVrcs = oi}) = oi
+tyConArgVrcs (PrimTyCon {argVrcs = oi}) = oi
+tyConArgVrcs (TupleTyCon {tyConArity = arity}) = (replicate arity (True,False))
+tyConArgVrcs (SynTyCon {argVrcs = oi}) = oi
\end{code}
\begin{code}
\begin{code}
maybeTyConSingleCon :: TyCon -> Maybe DataCon
-maybeTyConSingleCon (AlgTyCon {dataCons = [c]}) = Just c
-maybeTyConSingleCon (AlgTyCon {}) = Nothing
-maybeTyConSingleCon (TupleTyCon {dataCon = con}) = Just con
-maybeTyConSingleCon (PrimTyCon {}) = Nothing
+maybeTyConSingleCon (AlgTyCon {algRhs = DataTyCon [c] _}) = Just c
+maybeTyConSingleCon (AlgTyCon {algRhs = NewTyCon 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 (AlgTyCon {dataTyConClass_maybe = maybe_cls}) = maybe_cls
-tyConClass_maybe other_tycon = Nothing
+tyConClass_maybe (AlgTyCon {algTyConClass = maybe_clas}) = maybe_clas
+tyConClass_maybe ther_tycon = Nothing
\end{code}
getUnique tc = tyConUnique tc
instance Outputable TyCon where
- ppr tc = ppr (getName tc)
+ 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 that tc1.
-
-E.g. It's ok to bind a type variable
- tv :: k2
-to a type
- t :: k1
-
-\begin{code}
-matchesTyCon :: TyCon -- Expected (e.g. arg type of function)
- -> TyCon -- Inferred (e.g. type of actual arg to function)
- -> Bool
-
-matchesTyCon (KindCon {kindConBoxity = k1}) (KindCon {kindConBoxity = k2})
- = k2 `has_more` k1
- where
- -- "has_more" means has more boxity info
- Boxed `has_more` Open = True
- Boxed `has_more` Boxed = True
- Unboxed `has_more` Open = True
- Unboxed `has_more` Unboxed = True
- Open `has_more` Open = True
- k1 `has_more` k2 = False
-
-matchesTyCon tc1 tc2 = tyConUnique tc1 == tyConUnique tc2
-\end{code}
projects / ghc-hetmet.git / blobdiff