Safe Haskell  None 

Language  GHC2021 
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 tc
 type TyConBinder = VarBndr TyVar TyConBndrVis
 data TyConBndrVis
 mkNamedTyConBinder :: ForAllTyFlag > TyVar > TyConBinder
 mkNamedTyConBinders :: ForAllTyFlag > [TyVar] > [TyConBinder]
 mkRequiredTyConBinder :: TyCoVarSet > TyVar > TyConBinder
 mkAnonTyConBinder :: TyVar > TyConBinder
 mkAnonTyConBinders :: [TyVar] > [TyConBinder]
 tyConBinderForAllTyFlag :: TyConBinder > ForAllTyFlag
 tyConBndrVisForAllTyFlag :: TyConBndrVis > ForAllTyFlag
 isNamedTyConBinder :: TyConBinder > Bool
 isVisibleTyConBinder :: VarBndr tv TyConBndrVis > Bool
 isInvisibleTyConBinder :: VarBndr tv TyConBndrVis > Bool
 isVisibleTcbVis :: TyConBndrVis > Bool
 isInvisSpecTcbVis :: 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 > Bool > TyCon
 mkFamilyTyCon :: Name > [TyConBinder] > Kind > Maybe Name > FamTyConFlav > Maybe Class > Injectivity > TyCon
 mkPromotedDataCon :: DataCon > Name > TyConRepName > [TyConBinder] > Kind > [Role] > PromDataConInfo > TyCon
 mkTcTyCon :: Name > [TyConBinder] > Kind > [(Name, TcTyVar)] > Bool > TyConFlavour TyCon > 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
 isKindName :: Name > 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 tc > Maybe tc
 isImplicitTyCon :: TyCon > Bool
 isTyConWithSrcDataCons :: TyCon > Bool
 isTcTyCon :: TyCon > Bool
 setTcTyConKind :: TyCon > Kind > TyCon
 tcHasFixedRuntimeRep :: TyCon > Bool
 isConcreteTyCon :: TyCon > Bool
 isValidDTT2TyCon :: 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 TyCon
 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 tc > Bool
 type TyConRepName = Name
 tyConRepName_maybe :: TyCon > Maybe TyConRepName
 mkPrelTyConRepName :: Name > TyConRepName
 tyConRepModOcc :: Module > OccName > (Module, OccName)
 data PrimRep
 data PrimElemRep
 data Levity
 data PrimOrVoidRep
 primElemRepToPrimRep :: PrimElemRep > PrimRep
 isGcPtrRep :: PrimRep > Bool
 primRepSizeB :: Platform > PrimRep > Int
 primRepSizeW64_B :: PrimRep > Int
 primElemRepSizeB :: Platform > PrimElemRep > Int
 primElemRepSizeW64_B :: 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 Type
2) Type synonyms: type Foo = ...
creates the Foo
type constructor
3) Newtypes: newtype Foo a = MkFoo ...
creates the Foo
type constructor
of kind Type > Type
4) Class declarations: class Foo where
creates the Foo
type constructor
of kind Constraint
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
NamedThing TyCon Source #  
Uniquable TyCon Source #  
Outputable TyCon Source #  
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 # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c TyCon # dataTypeOf :: TyCon > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c TyCon) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c TyCon) # gmapT :: (forall b. Data b => b > b) > TyCon > TyCon # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > TyCon > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > TyCon > r # gmapQ :: (forall d. Data d => d > u) > TyCon > [u] # gmapQi :: Int > (forall d. Data d => d > u) > TyCon > u # gmapM :: Monad m => (forall d. Data d => d > m d) > TyCon > m TyCon # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > TyCon > m TyCon # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > TyCon > m TyCon #  
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 :: Type Or an associated data type declaration, within a class declaration: class C a b where data T b :: Type 
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
Binary Role Source #  
Outputable Role Source #  
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 # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c Role # dataTypeOf :: Role > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c Role) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c Role) # gmapT :: (forall b. Data b => b > b) > Role > Role # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Role > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > Role > r # gmapQ :: (forall d. Data d => d > u) > Role > [u] # gmapQi :: Int > (forall d. Data d => d > u) > Role > u # gmapM :: Monad m => (forall d. Data d => d > m d) > Role > m Role # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Role > m Role # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Role > m Role #  
Eq Role Source #  
Ord Role Source #  
type Anno (Maybe Role) Source #  
Defined in GHC.Hs.Decls 
data Injectivity Source #
Instances
Binary Injectivity Source #  
Defined in GHC.Core.TyCon put_ :: WriteBinHandle > Injectivity > IO () Source # put :: WriteBinHandle > Injectivity > IO (Bin Injectivity) Source # get :: ReadBinHandle > IO 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 tc Source #
Paints a picture of what a TyCon
represents, in broad strokes.
This is used towards more informative error messages.
Instances
Functor TyConFlavour Source #  
Defined in GHC.Types.Basic fmap :: (a > b) > TyConFlavour a > TyConFlavour b # (<$) :: a > TyConFlavour b > TyConFlavour a #  
NFData tc => NFData (TyConFlavour tc) Source #  
Defined in GHC.Types.Basic rnf :: TyConFlavour tc > () Source #  
Outputable (TyConFlavour tc) Source #  
Defined in GHC.Types.Basic ppr :: TyConFlavour tc > SDoc Source #  
Data tc => Data (TyConFlavour tc) Source #  
Defined in GHC.Types.Basic gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > TyConFlavour tc > c (TyConFlavour tc) # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c (TyConFlavour tc) # toConstr :: TyConFlavour tc > Constr # dataTypeOf :: TyConFlavour tc > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c (TyConFlavour tc)) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c (TyConFlavour tc)) # gmapT :: (forall b. Data b => b > b) > TyConFlavour tc > TyConFlavour tc # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > TyConFlavour tc > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > TyConFlavour tc > r # gmapQ :: (forall d. Data d => d > u) > TyConFlavour tc > [u] # gmapQi :: Int > (forall d. Data d => d > u) > TyConFlavour tc > u # gmapM :: Monad m => (forall d. Data d => d > m d) > TyConFlavour tc > m (TyConFlavour tc) # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > TyConFlavour tc > m (TyConFlavour tc) # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > TyConFlavour tc > m (TyConFlavour tc) #  
Eq tc => Eq (TyConFlavour tc) Source #  
Defined in GHC.Types.Basic (==) :: TyConFlavour tc > TyConFlavour tc > Bool # (/=) :: TyConFlavour tc > TyConFlavour tc > Bool # 
TyConBinder
type TyConBinder = VarBndr TyVar TyConBndrVis Source #
data TyConBndrVis Source #
NamedTCB ForAllTyFlag  A named, forallbound variable (invisible or not) 
AnonTCB  an ordinary, visible type argument 
Instances
Binary TyConBndrVis Source #  
Defined in GHC.Core.TyCon put_ :: WriteBinHandle > TyConBndrVis > IO () Source # put :: WriteBinHandle > TyConBndrVis > IO (Bin TyConBndrVis) Source # get :: ReadBinHandle > IO 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 
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 #
isInvisSpecTcbVis :: 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
).
:: Name  
> [TyConBinder]  
> Kind  result kind 
> [Role]  
> Type  
> Bool  
> Bool  
> Bool  
> Bool  
> TyCon 
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 > [TyConBinder] > 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; 
> Bool  Is this TcTyCon generalised already? 
> TyConFlavour TyCon  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 Note [TcTyCon, MonoTcTyCon, and PolyTcTyCon] 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 DataKinds
?
isKindName :: Name > Bool Source #
This is Name
really meant for use at the kind level? That is,
should it be permitted wihout DataKinds
?
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.
See Note [Forgetful type synonyms]
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?
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.Equality
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.Equality
NB: at Nominal role, isGenerativeTyCon is simple: isGenerativeTyCon tc Nominal = not (isTypeFamilyTyCon tc  isSynonymTyCon tc)
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 tc > Maybe tc 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?
More specifically, if tys
are all concrete, is (T tys) concrete?
(for synonyms this requires us to look at the RHS)
Used for representation polymorphism checks.
See Note [Concrete types] in GHC.Tc.Utils.Concrete
isValidDTT2TyCon :: TyCon > Bool Source #
Returns True
if a boxed type headed by the given TyCon
satisfies condition DTT2 of Note [DataToTag overview] in
GHC.Tc.Instance.Class
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 TyCon 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 tc > 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 nonvoid type.
(Use PrimRepOrVoidRep
if you want void types too.)
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.
BoxedRep !(Maybe Levity)  Boxed, heap value 
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 
FloatRep  
DoubleRep  
VecRep Int PrimElemRep  A vector 
Instances
Binary PrimRep Source #  
Outputable PrimRep Source #  
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 # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c PrimRep # toConstr :: PrimRep > Constr # dataTypeOf :: PrimRep > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c PrimRep) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c PrimRep) # gmapT :: (forall b. Data b => b > b) > PrimRep > PrimRep # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > PrimRep > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > PrimRep > r # gmapQ :: (forall d. Data d => d > u) > PrimRep > [u] # gmapQi :: Int > (forall d. Data d => d > u) > PrimRep > u # gmapM :: Monad m => (forall d. Data d => d > m d) > PrimRep > m PrimRep # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > PrimRep > m PrimRep # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > PrimRep > m PrimRep #  
Show PrimRep Source #  
Eq PrimRep Source #  
Ord PrimRep Source #  
data PrimElemRep Source #
Int8ElemRep  
Int16ElemRep  
Int32ElemRep  
Int64ElemRep  
Word8ElemRep  
Word16ElemRep  
Word32ElemRep  
Word64ElemRep  
FloatElemRep  
DoubleElemRep 
Instances
Instances
Binary Levity Source #  
Outputable Levity Source #  
Data Levity Source #  
Defined in GHC.Types.Basic gfoldl :: (forall d b. Data d => c (d > b) > d > c b) > (forall g. g > c g) > Levity > c Levity # gunfold :: (forall b r. Data b => c (b > r) > c r) > (forall r. r > c r) > Constr > c Levity # toConstr :: Levity > Constr # dataTypeOf :: Levity > DataType # dataCast1 :: Typeable t => (forall d. Data d => c (t d)) > Maybe (c Levity) # dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) > Maybe (c Levity) # gmapT :: (forall b. Data b => b > b) > Levity > Levity # gmapQl :: (r > r' > r) > r > (forall d. Data d => d > r') > Levity > r # gmapQr :: forall r r'. (r' > r > r) > r > (forall d. Data d => d > r') > Levity > r # gmapQ :: (forall d. Data d => d > u) > Levity > [u] # gmapQi :: Int > (forall d. Data d => d > u) > Levity > u # gmapM :: Monad m => (forall d. Data d => d > m d) > Levity > m Levity # gmapMp :: MonadPlus m => (forall d. Data d => d > m d) > Levity > m Levity # gmapMo :: MonadPlus m => (forall d. Data d => d > m d) > Levity > m Levity #  
Show Levity Source #  
Eq Levity Source #  
Ord Levity Source #  
data PrimOrVoidRep Source #
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.
primRepSizeW64_B :: PrimRep > Int Source #
Like primRepSizeB but assumes pointers/words are 8 words wide.
This can be useful to compute the size of a rep as if we were compiling for a 64bit platform.
primElemRepSizeB :: Platform > PrimElemRep > Int Source #
primElemRepSizeW64_B :: PrimElemRep > Int Source #
Like primElemRepSizeB but assumes pointers/words are 8 words wide.
This can be useful to compute the size of a rep as if we were compiling for a 64bit platform.
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 #