Safe Haskell  SafeInferred 

Language  Haskell2010 
Synopsis
 data TyCon
 data AlgTyConRhs
 = AbstractTyCon
  DataTyCon {
 data_cons :: [DataCon]
 data_cons_size :: Int
 is_enum :: Bool
 is_type_data :: Bool
 data_fixed_lev :: Bool
  TupleTyCon { }
  SumTyCon {
 data_cons :: [DataCon]
 data_cons_size :: Int
  NewTyCon {
 data_con :: DataCon
 nt_rhs :: Type
 nt_etad_rhs :: ([TyVar], Type)
 nt_co :: CoAxiom Unbranched
 nt_fixed_rep :: Bool
 visibleDataCons :: AlgTyConRhs > [DataCon]
 data AlgTyConFlav
 isNoParent :: AlgTyConFlav > Bool
 data FamTyConFlav
 data Role
 data Injectivity
 = NotInjective
  Injective [Bool]
 data PromDataConInfo
 = NoPromInfo
  RuntimeRep ([Type] > [PrimRep])
  VecCount Int
  VecElem PrimElemRep
  Levity Levity
 data TyConFlavour
 type TyConBinder = VarBndr TyVar TyConBndrVis
 data TyConBndrVis
 type TyConPiTyBinder = VarBndr TyCoVar TyConBndrVis
 mkNamedTyConBinder :: ForAllTyFlag > TyVar > TyConBinder
 mkNamedTyConBinders :: ForAllTyFlag > [TyVar] > [TyConBinder]
 mkRequiredTyConBinder :: TyCoVarSet > TyVar > TyConBinder
 mkAnonTyConBinder :: TyVar > TyConBinder
 mkAnonTyConBinders :: [TyVar] > [TyConBinder]
 mkInvisAnonTyConBinder :: TyVar > TyConBinder
 tyConBinderForAllTyFlag :: TyConBinder > ForAllTyFlag
 tyConBndrVisForAllTyFlag :: TyConBndrVis > ForAllTyFlag
 isNamedTyConBinder :: TyConBinder > Bool
 isVisibleTyConBinder :: VarBndr tv TyConBndrVis > Bool
 isInvisibleTyConBinder :: VarBndr tv TyConBndrVis > Bool
 isVisibleTcbVis :: TyConBndrVis > Bool
 tyConFieldLabels :: TyCon > [FieldLabel]
 lookupTyConFieldLabel :: FieldLabelString > TyCon > Maybe FieldLabel
 mkAlgTyCon :: Name > [TyConBinder] > Kind > [Role] > Maybe CType > [PredType] > AlgTyConRhs > AlgTyConFlav > Bool > TyCon
 mkClassTyCon :: Name > [TyConBinder] > [Role] > AlgTyConRhs > Class > Name > TyCon
 mkPrimTyCon :: Name > [TyConBinder] > Kind > [Role] > TyCon
 mkTupleTyCon :: Name > [TyConBinder] > Kind > DataCon > TupleSort > AlgTyConFlav > TyCon
 mkSumTyCon :: Name > [TyConBinder] > Kind > [DataCon] > AlgTyConFlav > TyCon
 mkDataTyConRhs :: [DataCon] > AlgTyConRhs
 mkLevPolyDataTyConRhs :: Bool > Bool > [DataCon] > AlgTyConRhs
 mkSynonymTyCon :: Name > [TyConBinder] > Kind > [Role] > Type > Bool > Bool > Bool > TyCon
 mkFamilyTyCon :: Name > [TyConBinder] > Kind > Maybe Name > FamTyConFlav > Maybe Class > Injectivity > TyCon
 mkPromotedDataCon :: DataCon > Name > TyConRepName > [TyConPiTyBinder] > Kind > [Role] > PromDataConInfo > TyCon
 mkTcTyCon :: Name > [TyConBinder] > Kind > [(Name, TcTyVar)] > Bool > TyConFlavour > TyCon
 noTcTyConScopedTyVars :: [(Name, TcTyVar)]
 isAlgTyCon :: TyCon > Bool
 isVanillaAlgTyCon :: TyCon > Bool
 isClassTyCon :: TyCon > Bool
 isFamInstTyCon :: TyCon > Bool
 isPrimTyCon :: TyCon > Bool
 isTupleTyCon :: TyCon > Bool
 isUnboxedTupleTyCon :: TyCon > Bool
 isBoxedTupleTyCon :: TyCon > Bool
 isUnboxedSumTyCon :: TyCon > Bool
 isPromotedTupleTyCon :: TyCon > Bool
 isLiftedAlgTyCon :: TyCon > Bool
 isTypeSynonymTyCon :: TyCon > Bool
 tyConMustBeSaturated :: TyCon > Bool
 isPromotedDataCon :: TyCon > Bool
 isPromotedDataCon_maybe :: TyCon > Maybe DataCon
 isDataKindsPromotedDataCon :: TyCon > Bool
 isKindTyCon :: TyCon > Bool
 isLiftedTypeKindTyConName :: Name > Bool
 isTauTyCon :: TyCon > Bool
 isFamFreeTyCon :: TyCon > Bool
 isForgetfulSynTyCon :: TyCon > Bool
 isDataTyCon :: TyCon > Bool
 isTypeDataTyCon :: TyCon > Bool
 isEnumerationTyCon :: TyCon > Bool
 isNewTyCon :: TyCon > Bool
 isAbstractTyCon :: TyCon > Bool
 isFamilyTyCon :: TyCon > Bool
 isOpenFamilyTyCon :: TyCon > Bool
 isTypeFamilyTyCon :: TyCon > Bool
 isDataFamilyTyCon :: TyCon > Bool
 isOpenTypeFamilyTyCon :: TyCon > Bool
 isClosedSynFamilyTyConWithAxiom_maybe :: TyCon > Maybe (CoAxiom Branched)
 tyConInjectivityInfo :: TyCon > Injectivity
 isBuiltInSynFamTyCon_maybe :: TyCon > Maybe BuiltInSynFamily
 isGadtSyntaxTyCon :: TyCon > Bool
 isInjectiveTyCon :: TyCon > Role > Bool
 isGenerativeTyCon :: TyCon > Role > Bool
 isGenInjAlgRhs :: AlgTyConRhs > Bool
 isTyConAssoc :: TyCon > Bool
 tyConAssoc_maybe :: TyCon > Maybe TyCon
 tyConFlavourAssoc_maybe :: TyConFlavour > Maybe TyCon
 isImplicitTyCon :: TyCon > Bool
 isTyConWithSrcDataCons :: TyCon > Bool
 isTcTyCon :: TyCon > Bool
 setTcTyConKind :: TyCon > Kind > TyCon
 tcHasFixedRuntimeRep :: TyCon > Bool
 isConcreteTyCon :: TyCon > Bool
 tyConName :: TyCon > Name
 tyConSkolem :: TyCon > Bool
 tyConKind :: TyCon > Kind
 tyConUnique :: TyCon > Unique
 tyConTyVars :: TyCon > [TyVar]
 tyConVisibleTyVars :: TyCon > [TyVar]
 tyConCType_maybe :: TyCon > Maybe CType
 tyConDataCons :: TyCon > [DataCon]
 tyConDataCons_maybe :: TyCon > Maybe [DataCon]
 tyConSingleDataCon_maybe :: TyCon > Maybe DataCon
 tyConSingleDataCon :: TyCon > DataCon
 tyConAlgDataCons_maybe :: TyCon > Maybe [DataCon]
 tyConSingleAlgDataCon_maybe :: TyCon > Maybe DataCon
 tyConFamilySize :: TyCon > Int
 tyConStupidTheta :: TyCon > [PredType]
 tyConArity :: TyCon > Arity
 tyConNullaryTy :: TyCon > Type
 mkTyConTy :: TyCon > Type
 tyConRoles :: TyCon > [Role]
 tyConFlavour :: TyCon > TyConFlavour
 tyConTuple_maybe :: TyCon > Maybe TupleSort
 tyConClass_maybe :: TyCon > Maybe Class
 tyConATs :: TyCon > [TyCon]
 tyConFamInst_maybe :: TyCon > Maybe (TyCon, [Type])
 tyConFamInstSig_maybe :: TyCon > Maybe (TyCon, [Type], CoAxiom Unbranched)
 tyConFamilyCoercion_maybe :: TyCon > Maybe (CoAxiom Unbranched)
 tyConFamilyResVar_maybe :: TyCon > Maybe Name
 synTyConDefn_maybe :: TyCon > Maybe ([TyVar], Type)
 synTyConRhs_maybe :: TyCon > Maybe Type
 famTyConFlav_maybe :: TyCon > Maybe FamTyConFlav
 algTyConRhs :: TyCon > AlgTyConRhs
 newTyConRhs :: TyCon > ([TyVar], Type)
 newTyConEtadArity :: TyCon > Int
 newTyConEtadRhs :: TyCon > ([TyVar], Type)
 unwrapNewTyCon_maybe :: TyCon > Maybe ([TyVar], Type, CoAxiom Unbranched)
 unwrapNewTyConEtad_maybe :: TyCon > Maybe ([TyVar], Type, CoAxiom Unbranched)
 newTyConDataCon_maybe :: TyCon > Maybe DataCon
 algTcFields :: TyConDetails > FieldLabelEnv
 tyConPromDataConInfo :: TyCon > PromDataConInfo
 tyConBinders :: TyCon > [TyConBinder]
 tyConResKind :: TyCon > Kind
 tyConInvisTVBinders :: [TyConBinder] > [InvisTVBinder]
 tcTyConScopedTyVars :: TyCon > [(Name, TcTyVar)]
 isMonoTcTyCon :: TyCon > Bool
 tyConHasClosedResKind :: TyCon > Bool
 mkTyConTagMap :: TyCon > NameEnv ConTag
 data ExpandSynResult tyco
 = NoExpansion
  ExpandsSyn [(TyVar, tyco)] Type [tyco]
 expandSynTyCon_maybe :: TyCon > [tyco] > ExpandSynResult tyco
 newTyConCo :: TyCon > CoAxiom Unbranched
 newTyConCo_maybe :: TyCon > Maybe (CoAxiom Unbranched)
 pprPromotionQuote :: TyCon > SDoc
 mkTyConKind :: [TyConBinder] > Kind > Kind
 tcFlavourIsOpen :: TyConFlavour > Bool
 type TyConRepName = Name
 tyConRepName_maybe :: TyCon > Maybe TyConRepName
 mkPrelTyConRepName :: Name > TyConRepName
 tyConRepModOcc :: Module > OccName > (Module, OccName)
 data PrimRep
 data PrimElemRep
 primElemRepToPrimRep :: PrimElemRep > PrimRep
 isVoidRep :: PrimRep > Bool
 isGcPtrRep :: PrimRep > Bool
 primRepSizeB :: Platform > PrimRep > Int
 primElemRepSizeB :: Platform > PrimElemRep > Int
 primRepIsFloat :: PrimRep > Maybe Bool
 primRepsCompatible :: Platform > [PrimRep] > [PrimRep] > Bool
 primRepCompatible :: Platform > PrimRep > PrimRep > Bool
 primRepIsWord :: PrimRep > Bool
 primRepIsInt :: PrimRep > Bool
Main TyCon data types
TyCons represent type constructors. Type constructors are introduced by things such as:
1) Data declarations: data Foo = ...
creates the Foo
type constructor of
kind *
2) Type synonyms: type Foo = ...
creates the Foo
type constructor
3) Newtypes: newtype Foo a = MkFoo ...
creates the Foo
type constructor
of kind * > *
4) Class declarations: class Foo where
creates the Foo
type constructor
of kind *
This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.
If you edit this type, you may need to update the GHC formalism See Note [GHC Formalism] in GHC.Core.Lint
Instances
Data TyCon Source #  
Defined in GHC.Core.TyCon gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > TyCon > c TyCon Source # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c TyCon Source # toConstr :: TyCon > Constr Source # dataTypeOf :: TyCon > DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c TyCon) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c TyCon) Source # gmapT :: (forall b. Data b => b > b) > TyCon > TyCon Source # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > TyCon > r Source # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > TyCon > r Source # gmapQ :: (forall d. Data d => d > u) > TyCon > [u] Source # gmapQi :: Int > (forall d. Data d => d > u) > TyCon > u Source # gmapM :: Monad m => (forall d. Data d => d > m d) > TyCon > m TyCon Source # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > TyCon > m TyCon Source # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > TyCon > m TyCon Source #  
NamedThing TyCon Source #  
Uniquable TyCon Source #  
Outputable TyCon Source #  
Eq TyCon Source #  
data AlgTyConRhs Source #
Represents righthandsides of TyCon
s for algebraic types
AbstractTyCon  Says that 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  Information about those 
 
TupleTyCon  
SumTyCon  An unboxed sum type. 
 
NewTyCon  Information about those 

visibleDataCons :: AlgTyConRhs > [DataCon] Source #
Extract those DataCon
s that we are able to learn about. Note
that visibility in this sense does not correspond to visibility in
the context of any particular user program!
data AlgTyConFlav Source #
Describes the flavour of an algebraic type constructor. For
classes and data families, this flavour includes a reference to
the parent TyCon
.
VanillaAlgTyCon TyConRepName  An ordinary algebraic type constructor. This includes unlifted and representationpolymorphic datatypes and newtypes and unboxed tuples, but NOT unboxed sums; see UnboxedSumTyCon. 
UnboxedSumTyCon  An unboxed sum type constructor. This is distinct from VanillaAlgTyCon because we currently don't allow unboxed sums to be Typeable since there are too many of them. See #13276. 
ClassTyCon Class TyConRepName  Type constructors representing a class dictionary. See Note [ATyCon for classes] in GHC.Core.TyCo.Rep 
DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type]  Type constructors representing an *instance* of a *data* family. Parameters: 1) The type family in question 2) Instance types; free variables are the 3) A 
Instances
Outputable AlgTyConFlav Source #  
Defined in GHC.Core.TyCon ppr :: AlgTyConFlav > SDoc Source # 
isNoParent :: AlgTyConFlav > Bool Source #
data FamTyConFlav Source #
Information pertaining to the expansion of a type synonym (type
)
DataFamilyTyCon TyConRepName  Represents an open type family without a fixed right hand side. Additional instances can appear at any time. These are introduced by either a top level declaration: data family T a :: * Or an associated data type declaration, within a class declaration: class C a b where data T b :: * 
OpenSynFamilyTyCon  An open type synonym family e.g. 
ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))  A closed type synonym family e.g.

AbstractClosedSynFamilyTyCon  A closed type synonym family declared in an hsboot file with type family F a where .. 
BuiltInSynFamTyCon BuiltInSynFamily  Builtin type family used by the TypeNats solver 
Instances
Outputable FamTyConFlav Source #  
Defined in GHC.Core.TyCon ppr :: FamTyConFlav > SDoc Source # 
See Note [Roles] in GHC.Core.Coercion
Order of constructors matters: the Ord instance coincides with the *super*typing relation on roles.
Instances
Data Role Source #  
Defined in Language.Haskell.Syntax.Basic gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > Role > c Role Source # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c Role Source # toConstr :: Role > Constr Source # dataTypeOf :: Role > DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c Role) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c Role) Source # gmapT :: (forall b. Data b => b > b) > Role > Role Source # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Role > r Source # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > Role > r Source # gmapQ :: (forall d. Data d => d > u) > Role > [u] Source # gmapQi :: Int > (forall d. Data d => d > u) > Role > u Source # gmapM :: Monad m => (forall d. Data d => d > m d) > Role > m Role Source # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Role > m Role Source # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Role > m Role Source #  
Binary Role Source #  
Outputable Role Source #  
Eq Role Source #  
Ord Role Source #  
type Anno (Maybe Role) Source #  
type Anno (Maybe Role) Source #  
data Injectivity Source #
Instances
Binary Injectivity Source #  
Defined in GHC.Core.TyCon put_ :: BinHandle > Injectivity > IO () Source # put :: BinHandle > Injectivity > IO (Bin Injectivity) Source #  
Eq Injectivity Source #  
Defined in GHC.Core.TyCon (==) :: Injectivity > Injectivity > Bool # (/=) :: Injectivity > Injectivity > Bool # 
data PromDataConInfo Source #
Some promoted datacons signify extra info relevant to GHC. For example,
the IntRep
constructor of RuntimeRep
corresponds to the IntRep
constructor of PrimRep
. This data structure allows us to store this
information right in the TyCon
. The other approach would be to look
up things like RuntimeRep
's PrimRep
by knownkey every time.
See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType
NoPromInfo  an ordinary promoted data con 
RuntimeRep ([Type] > [PrimRep])  A constructor of 
VecCount Int  A constructor of 
VecElem PrimElemRep  A constructor of 
Levity Levity  A constructor of 
data TyConFlavour Source #
Paints a picture of what a TyCon
represents, in broad strokes.
This is used towards more informative error messages.
Instances
Outputable TyConFlavour Source #  
Defined in GHC.Core.TyCon ppr :: TyConFlavour > SDoc Source #  
Eq TyConFlavour Source #  
Defined in GHC.Core.TyCon (==) :: TyConFlavour > TyConFlavour > Bool # (/=) :: TyConFlavour > TyConFlavour > Bool # 
TyConBinder
type TyConBinder = VarBndr TyVar TyConBndrVis Source #
data TyConBndrVis Source #
Instances
Binary TyConBndrVis Source #  
Defined in GHC.Core.TyCon put_ :: BinHandle > TyConBndrVis > IO () Source # put :: BinHandle > TyConBndrVis > IO (Bin TyConBndrVis) Source #  
Outputable TyConBndrVis Source #  
Defined in GHC.Core.TyCon ppr :: TyConBndrVis > SDoc Source #  
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis) Source #  
Defined in GHC.Core.TyCon 
type TyConPiTyBinder = VarBndr TyCoVar TyConBndrVis Source #
mkNamedTyConBinder :: ForAllTyFlag > TyVar > TyConBinder Source #
mkNamedTyConBinders :: ForAllTyFlag > [TyVar] > [TyConBinder] Source #
mkRequiredTyConBinder :: TyCoVarSet > TyVar > TyConBinder Source #
Make a Required TyConBinder. It chooses between NamedTCB and AnonTCB based on whether the tv is mentioned in the dependent set
mkAnonTyConBinder :: TyVar > TyConBinder Source #
mkAnonTyConBinders :: [TyVar] > [TyConBinder] Source #
isNamedTyConBinder :: TyConBinder > Bool Source #
isVisibleTyConBinder :: VarBndr tv TyConBndrVis > Bool Source #
isInvisibleTyConBinder :: VarBndr tv TyConBndrVis > Bool Source #
isVisibleTcbVis :: TyConBndrVis > Bool Source #
Field labels
tyConFieldLabels :: TyCon > [FieldLabel] Source #
The labels for the fields of this particular TyCon
lookupTyConFieldLabel :: FieldLabelString > TyCon > Maybe FieldLabel Source #
Look up a field label belonging to this TyCon
Constructing TyCons
:: Name  
> [TyConBinder]  Binders of the 
> Kind  Result kind 
> [Role]  The roles for each TyVar 
> Maybe CType  The C type this type corresponds to when using the CAPI FFI 
> [PredType]  Stupid theta: see 
> AlgTyConRhs  Information about data constructors 
> AlgTyConFlav  What flavour is it? (e.g. vanilla, type family) 
> Bool  Was the 
> TyCon 
This is the making of an algebraic TyCon
.
mkClassTyCon :: Name > [TyConBinder] > [Role] > AlgTyConRhs > Class > Name > TyCon Source #
Simpler specialization of mkAlgTyCon
for classes
:: Name  
> [TyConBinder]  
> Kind  result kind
Must answer 
> [Role]  
> TyCon 
Create an primitive TyCon
, such as Int#
, Type
or RealWorld#
Primitive TyCons are marshalable iff not lifted.
If you'd like to change this, modify marshalablePrimTyCon.
:: Name  
> [TyConBinder]  
> Kind  Result kind of the 
> DataCon  
> TupleSort  Whether the tuple is boxed or unboxed 
> AlgTyConFlav  
> TyCon 
:: Name  
> [TyConBinder]  
> Kind  Kind of the resulting 
> [DataCon]  
> AlgTyConFlav  
> TyCon 
mkDataTyConRhs :: [DataCon] > AlgTyConRhs Source #
Create an AlgTyConRhs
from the data constructors.
Use mkLevPolyDataConRhs
if the datatype can be levitypolymorphic
or if it comes from a "data type" declaration
mkLevPolyDataTyConRhs Source #
:: Bool  whether the 
> Bool  True if this is a "type data" declaration See Note [Type data declarations] in GHC.Rename.Module 
> [DataCon]  
> AlgTyConRhs 
Create an AlgTyConRhs
from the data constructors,
for a potentially levitypolymorphic datatype (with UnliftedDatatypes
).
Create a type synonym TyCon
:: Name  
> [TyConBinder]  
> Kind  result kind 
> Maybe Name  
> FamTyConFlav  
> Maybe Class  
> Injectivity  
> TyCon 
Create a type family TyCon
mkPromotedDataCon :: DataCon > Name > TyConRepName > [TyConPiTyBinder] > Kind > [Role] > PromDataConInfo > TyCon Source #
Create a promoted data constructor TyCon
Somewhat dodgily, we give it the same Name
as the data constructor itself; when we prettyprint
the TyCon we add a quote; see the Outputable TyCon instance
:: Name  
> [TyConBinder]  
> Kind  result kind only 
> [(Name, TcTyVar)]  Scoped type variables; see Note [How TcTyCons work] in GHC.Tc.TyCl 
> Bool  Is this TcTyCon generalised already? 
> TyConFlavour  What sort of 
> TyCon 
Makes a tycon suitable for use during typechecking. It stores a variety of details about the definition of the TyCon, but no righthand side. It lives only during the typechecking of a mutuallyrecursive group of tycons; it is then zonked to a proper TyCon in zonkTcTyCon. See also Note [Kind checking recursive type and class declarations] in GHC.Tc.TyCl.
noTcTyConScopedTyVars :: [(Name, TcTyVar)] Source #
No scoped type variables (to be used with mkTcTyCon).
Predicates on TyCons
isAlgTyCon :: TyCon > Bool Source #
Returns True
if the supplied TyCon
resulted from either a
data
or newtype
declaration
isVanillaAlgTyCon :: TyCon > Bool Source #
Returns True
for vanilla AlgTyCons  that is, those created
with a data
or newtype
declaration.
isPrimTyCon :: TyCon > Bool Source #
Does this TyCon
represent something that cannot be defined in Haskell?
isTupleTyCon :: TyCon > Bool Source #
Does this TyCon
represent a tuple?
NB: when compiling Data.Tuple
, the tycons won't reply True
to
isTupleTyCon
, because they are built as AlgTyCons
. However they
get spat into the interface file as tuple tycons, so I don't think
it matters.
isLiftedAlgTyCon :: TyCon > Bool Source #
isTypeSynonymTyCon :: TyCon > Bool Source #
Is this a TyCon
representing a regular H98 type synonym (type
)?
tyConMustBeSaturated :: TyCon > Bool Source #
True iff we can decompose (T a b c) into ((T a b) c) I.e. is it injective and generative w.r.t nominal equality? That is, if (T a b) ~N d e f, is it always the case that (T ~N d), (a ~N e) and (b ~N f)? Specifically NOT true of synonyms (open and otherwise)
It'd be unusual to call tyConMustBeSaturated on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable
isPromotedDataCon :: TyCon > Bool Source #
Is this a PromotedDataCon?
isPromotedDataCon_maybe :: TyCon > Maybe DataCon Source #
Retrieves the promoted DataCon if this is a PromotedDataCon;
isDataKindsPromotedDataCon :: TyCon > Bool Source #
This function identifies PromotedDataCon's from data constructors in `data T = K1  K2`, promoted by XDataKinds. These type constructors are printed with a tick mark 'K1 and 'K2, and similarly have a tick mark added to their OccName's.
In contrast, constructors in `type data T = K1  K2` are printed and represented with their original undecorated names. See Note [Type data declarations] in GHC.Rename.Module
isKindTyCon :: TyCon > Bool Source #
Is this tycon really meant for use at the kind level? That is, should it be permitted without XDataKinds?
isLiftedTypeKindTyConName :: Name > Bool Source #
isTauTyCon :: TyCon > Bool Source #
isFamFreeTyCon :: TyCon > Bool Source #
Is this tycon neither a type family nor a synonym that expands to a type family?
isForgetfulSynTyCon :: TyCon > Bool Source #
Is this a forgetful type synonym? If this is a type synonym whose RHS does not mention one (or more) of its bound variables, returns True. Thus, False means that all bound variables appear on the RHS; True may not mean anything, as the test to set this flag is conservative.
isDataTyCon :: TyCon > Bool Source #
Returns True
for data types that are definitely represented by
heapallocated constructors. These are scrutinised by Corelevel
case
expressions, and they get info tables allocated for them.
Generally, the function will be true for all data
types and false
for newtype
s, unboxed tuples, unboxed sums and type family
TyCon
s. But it is not guaranteed to return True
in all cases
that it could.
NB: for a data type family, only the instance TyCon
s
get an info table. The family declaration TyCon
does not
isTypeDataTyCon :: TyCon > Bool Source #
Was this TyCon
declared as "type data"?
See Note [Type data declarations] in GHC.Rename.Module.
isEnumerationTyCon :: TyCon > Bool Source #
Is this an algebraic TyCon
which is just an enumeration of values?
isAbstractTyCon :: TyCon > Bool Source #
Test if the TyCon
is algebraic but abstract (invisible data constructors)
isFamilyTyCon :: TyCon > Bool Source #
Is this a TyCon
, synonym or otherwise, that defines a family?
isOpenFamilyTyCon :: TyCon > Bool Source #
Is this a TyCon
, synonym or otherwise, that defines a family with
instances?
isTypeFamilyTyCon :: TyCon > Bool Source #
Is this a synonym TyCon
that can have may have further instances appear?
isDataFamilyTyCon :: TyCon > Bool Source #
Is this a synonym TyCon
that can have may have further instances appear?
isOpenTypeFamilyTyCon :: TyCon > Bool Source #
Is this an open type family TyCon?
isClosedSynFamilyTyConWithAxiom_maybe :: TyCon > Maybe (CoAxiom Branched) Source #
Is this a nonempty closed type family? Returns Nothing
for
abstract or empty closed families.
tyConInjectivityInfo :: TyCon > Injectivity Source #
returns tyConInjectivityInfo
tc
if Injective
istc
is an
injective tycon (where is
states for which tyConBinders
tc
is
injective), or NotInjective
otherwise.
isGadtSyntaxTyCon :: TyCon > Bool Source #
Is this an algebraic TyCon
declared with the GADT syntax?
isInjectiveTyCon :: TyCon > Role > Bool Source #
isInjectiveTyCon
is true of TyCon
s for which this property holds
(where r is the role passed in):
If (T a1 b1 c1) ~r (T a2 b2 c2), then (a1 ~r1 a2), (b1 ~r2 b2), and (c1 ~r3 c2)
(where r1, r2, and r3, are the roles given by tyConRolesX tc r)
See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.Canonical
isGenerativeTyCon :: TyCon > Role > Bool Source #
isGenerativeTyCon
is true of TyCon
s for which this property holds
(where r is the role passed in):
If (T tys ~r t), then (t's head ~r T).
See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.Canonical
isGenInjAlgRhs :: AlgTyConRhs > Bool Source #
Is this an AlgTyConRhs
of a TyCon
that is generative and injective
with respect to representational equality?
isTyConAssoc :: TyCon > Bool Source #
Is this TyCon for an associated type?
tyConAssoc_maybe :: TyCon > Maybe TyCon Source #
Get the enclosing class TyCon (if there is one) for the given TyCon.
tyConFlavourAssoc_maybe :: TyConFlavour > Maybe TyCon Source #
Get the enclosing class TyCon (if there is one) for the given TyConFlavour
isImplicitTyCon :: TyCon > Bool Source #
Identifies implicit tycons that, in particular, do not go into interface files (because they are implicitly reconstructed when the interface is read).
Note that:
 Associated families are implicit, as they are reconstructed from the class declaration in which they reside, and
 Family instances are not implicit as they represent the instance body
(similar to a
dfun
does that for a class instance).  Tuples are implicit iff they have a wiredin name (namely: boxed and unboxed tuples are wiredin and implicit, but constraint tuples are not)
isTyConWithSrcDataCons :: TyCon > Bool Source #
Check if the tycon actually refers to a proper `data` or `newtype` with user defined constructors rather than one from a class or other construction.
isTcTyCon :: TyCon > Bool Source #
Is this a TcTyCon? (That is, one only used during typechecking?)
tcHasFixedRuntimeRep :: TyCon > Bool Source #
Does this TyCon
have a syntactically fixed RuntimeRep when fully applied,
as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete?
False is safe. True means we're sure. Does only a quick check, based on the TyCon's category.
See Note [Representationpolymorphic TyCons]
isConcreteTyCon :: TyCon > Bool Source #
Is this TyCon
concrete (i.e. not a synonym/type family)?
Used for representation polymorphism checks.
Extracting information out of TyCons
tyConSkolem :: TyCon > Bool Source #
Returns whether or not this TyCon
is definite, or a hole
that may be filled in at some later point. See Note [Skolem abstract data]
tyConUnique :: TyCon > Unique Source #
A Unique of this TyCon. Invariant: identical to Unique of Name stored in tyConName field.
tyConTyVars :: TyCon > [TyVar] Source #
TyVar binders
tyConVisibleTyVars :: TyCon > [TyVar] Source #
tyConDataCons :: TyCon > [DataCon] Source #
As tyConDataCons_maybe
, but returns the empty list of constructors if no
constructors could be found
tyConSingleDataCon :: TyCon > DataCon Source #
Like tyConSingleDataCon_maybe
, but panics if Nothing
.
tyConAlgDataCons_maybe :: TyCon > Maybe [DataCon] Source #
Returns Just dcs
if the given TyCon
is a data
type, a tuple type
or a sum type with data constructors dcs. If the TyCon
has more than one
constructor, or represents a primitive or function type constructor then
Nothing
is returned.
Like tyConDataCons_maybe
, but returns Nothing
for newtypes.
tyConSingleAlgDataCon_maybe :: TyCon > Maybe DataCon Source #
Like tyConSingleDataCon_maybe
, but returns Nothing
for newtypes.
tyConFamilySize :: TyCon > Int Source #
tyConStupidTheta :: TyCon > [PredType] Source #
Find the "stupid theta" of the TyCon
. A "stupid theta" is the context
to the left of an algebraic type declaration, e.g. Eq a
in the declaration
data Eq a => T a ...
. See Note [The stupid context]
in GHC.Core.DataCon.
tyConArity :: TyCon > Arity Source #
Arity
tyConNullaryTy :: TyCon > Type Source #
A preallocated TyConApp tycon []
mkTyConTy :: TyCon > Type Source #
(mkTyConTy tc) returns (TyConApp tc []) but arranges to share that TyConApp among all calls See Note [Sharing nullary TyConApps] So it's just an alias for tyConNullaryTy!
tyConRoles :: TyCon > [Role] Source #
The role for each type variable This list has length = tyConArity See also Note [TyCon Role signatures]
tyConFlavour :: TyCon > TyConFlavour Source #
tyConClass_maybe :: TyCon > Maybe Class Source #
If this TyCon
is that for a class instance, return the class it is for.
Otherwise returns Nothing
tyConFamInst_maybe :: TyCon > Maybe (TyCon, [Type]) Source #
If this TyCon
is that of a data family instance, return the family in question
and the instance types. Otherwise, return Nothing
tyConFamInstSig_maybe :: TyCon > Maybe (TyCon, [Type], CoAxiom Unbranched) Source #
tyConFamilyResVar_maybe :: TyCon > Maybe Name Source #
Extract type variable naming the result of injective type family
synTyConDefn_maybe :: TyCon > Maybe ([TyVar], Type) Source #
Extract the TyVar
s bound by a vanilla type synonym
and the corresponding (unsubstituted) right hand side.
synTyConRhs_maybe :: TyCon > Maybe Type Source #
Extract the information pertaining to the right hand side of a type synonym
(type
) declaration.
famTyConFlav_maybe :: TyCon > Maybe FamTyConFlav Source #
Extract the flavour of a type family (with all the extra information that it carries)
algTyConRhs :: TyCon > AlgTyConRhs Source #
Extract an AlgTyConRhs
with information about data constructors from an
algebraic or tuple TyCon
. Panics for any other sort of TyCon
newTyConEtadArity :: TyCon > Int Source #
The number of type parameters that need to be passed to a newtype to resolve it. May be less than in the definition if it can be etacontracted.
unwrapNewTyCon_maybe :: TyCon > Maybe ([TyVar], Type, CoAxiom Unbranched) Source #
unwrapNewTyConEtad_maybe :: TyCon > Maybe ([TyVar], Type, CoAxiom Unbranched) Source #
algTcFields :: TyConDetails > FieldLabelEnv Source #
Maps a label to information about the field
tyConPromDataConInfo :: TyCon > PromDataConInfo Source #
Extract any RuntimeRepInfo
from this TyCon
tyConBinders :: TyCon > [TyConBinder] Source #
Full binders
tyConResKind :: TyCon > Kind Source #
Result kind
tyConInvisTVBinders :: [TyConBinder] > [InvisTVBinder] Source #
isMonoTcTyCon :: TyCon > Bool Source #
tyConHasClosedResKind :: TyCon > Bool Source #
Manipulating TyCons
data ExpandSynResult tyco Source #
NoExpansion  
ExpandsSyn [(TyVar, tyco)] Type [tyco] 
:: TyCon  
> [tyco]  Arguments to 
> ExpandSynResult tyco  Returns a 
newTyConCo :: TyCon > CoAxiom Unbranched Source #
newTyConCo_maybe :: TyCon > Maybe (CoAxiom Unbranched) Source #
pprPromotionQuote :: TyCon > SDoc Source #
mkTyConKind :: [TyConBinder] > Kind > Kind Source #
Predicated on TyConFlavours
tcFlavourIsOpen :: TyConFlavour > Bool Source #
Is this flavour of TyCon
an open type family or a data family?
Runtime type representation
type TyConRepName = Name Source #
mkPrelTyConRepName :: Name > TyConRepName Source #
Make a Name
for the Typeable
representation of the given wiredin type
tyConRepModOcc :: Module > OccName > (Module, OccName) Source #
The name (and defining module) for the Typeable representation (TyCon) of a type constructor.
See Note [Grand plan for Typeable] in GHC.Tc.Instance.Typeable.
Primitive representations of Types
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. See also Note [RuntimeRep and PrimRep] in
GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.
VoidRep  
LiftedRep  
UnliftedRep  Unlifted pointer 
Int8Rep  Signed, 8bit value 
Int16Rep  Signed, 16bit value 
Int32Rep  Signed, 32bit value 
Int64Rep  Signed, 64 bit value 
IntRep  Signed, wordsized value 
Word8Rep  Unsigned, 8 bit value 
Word16Rep  Unsigned, 16 bit value 
Word32Rep  Unsigned, 32 bit value 
Word64Rep  Unsigned, 64 bit value 
WordRep  Unsigned, wordsized value 
AddrRep  A pointer, but not to a Haskell value (use '(Un)liftedRep') 
FloatRep  
DoubleRep  
VecRep Int PrimElemRep  A vector 
Instances
Data PrimRep Source #  
Defined in GHC.Core.TyCon gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > PrimRep > c PrimRep Source # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c PrimRep Source # toConstr :: PrimRep > Constr Source # dataTypeOf :: PrimRep > DataType Source # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c PrimRep) Source # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c PrimRep) Source # gmapT :: (forall b. Data b => b > b) > PrimRep > PrimRep Source # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > PrimRep > r Source # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > PrimRep > r Source # gmapQ :: (forall d. Data d => d > u) > PrimRep > [u] Source # gmapQi :: Int > (forall d. Data d => d > u) > PrimRep > u Source # gmapM :: Monad m => (forall d. Data d => d > m d) > PrimRep > m PrimRep Source # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > PrimRep > m PrimRep Source # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > PrimRep > m PrimRep Source #  
Show PrimRep Source #  
Binary PrimRep Source #  
Outputable PrimRep Source #  
Eq PrimRep Source #  
Ord PrimRep Source #  
data PrimElemRep Source #
Int8ElemRep  
Int16ElemRep  
Int32ElemRep  
Int64ElemRep  
Word8ElemRep  
Word16ElemRep  
Word32ElemRep  
Word64ElemRep  
FloatElemRep  
DoubleElemRep 
Instances
isGcPtrRep :: PrimRep > Bool Source #
primRepSizeB :: Platform > PrimRep > Int Source #
The size of a PrimRep
in bytes.
This applies also when used in a constructor, where we allow packing the
fields. For instance, in data Foo = Foo Float# Float#
the two fields will
take only 8 bytes, which for 64bit arch will be equal to 1 word.
See also mkVirtHeapOffsetsWithPadding for details of how data fields are
laid out.
primElemRepSizeB :: Platform > PrimElemRep > Int Source #
primRepIsFloat :: PrimRep > Maybe Bool Source #
Return if Rep stands for floating type, returns Nothing for vector types.
primRepIsWord :: PrimRep > Bool Source #
primRepIsInt :: PrimRep > Bool Source #