Safe Haskell  None 

Language  Haskell2010 
 data TyCon
 data AlgTyConRhs
 visibleDataCons :: AlgTyConRhs > [DataCon]
 data AlgTyConFlav
 isNoParent :: AlgTyConFlav > Bool
 data FamTyConFlav
 data Role
 data Injectivity
 = NotInjective
  Injective [Bool]
 data RuntimeRepInfo
 = NoRRI
  RuntimeRep ([Type] > [PrimRep])
  VecCount Int
  VecElem PrimElemRep
 type TyConBinder = TyVarBndr TyVar TyConBndrVis
 data TyConBndrVis
 mkNamedTyConBinder :: ArgFlag > TyVar > TyConBinder
 mkNamedTyConBinders :: ArgFlag > [TyVar] > [TyConBinder]
 mkAnonTyConBinder :: TyVar > TyConBinder
 mkAnonTyConBinders :: [TyVar] > [TyConBinder]
 tyConBinderArgFlag :: TyConBinder > ArgFlag
 isNamedTyConBinder :: TyConBinder > Bool
 isVisibleTyConBinder :: TyVarBndr tv TyConBndrVis > Bool
 isInvisibleTyConBinder :: TyVarBndr tv 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
 mkFunTyCon :: Name > [TyConBinder] > Name > TyCon
 mkPrimTyCon :: Name > [TyConBinder] > Kind > [Role] > TyCon
 mkKindTyCon :: Name > [TyConBinder] > Kind > [Role] > Name > TyCon
 mkLiftedPrimTyCon :: Name > [TyConBinder] > Kind > [Role] > TyCon
 mkTupleTyCon :: Name > [TyConBinder] > Kind > Arity > DataCon > TupleSort > AlgTyConFlav > TyCon
 mkSumTyCon :: Name > [TyConBinder] > Kind > Arity > [TyVar] > [DataCon] > AlgTyConFlav > TyCon
 mkSynonymTyCon :: Name > [TyConBinder] > Kind > [Role] > Type > Bool > Bool > TyCon
 mkFamilyTyCon :: Name > [TyConBinder] > Kind > Maybe Name > FamTyConFlav > Maybe Class > Injectivity > TyCon
 mkPromotedDataCon :: DataCon > Name > TyConRepName > [TyConBinder] > Kind > [Role] > RuntimeRepInfo > TyCon
 mkTcTyCon :: Name > [TyConBinder] > Kind > Bool > [TyVar] > TyCon
 isAlgTyCon :: TyCon > Bool
 isVanillaAlgTyCon :: TyCon > Bool
 isClassTyCon :: TyCon > Bool
 isFamInstTyCon :: TyCon > Bool
 isFunTyCon :: TyCon > Bool
 isPrimTyCon :: TyCon > Bool
 isTupleTyCon :: TyCon > Bool
 isUnboxedTupleTyCon :: TyCon > Bool
 isBoxedTupleTyCon :: TyCon > Bool
 isUnboxedSumTyCon :: TyCon > Bool
 isPromotedTupleTyCon :: TyCon > Bool
 isTypeSynonymTyCon :: TyCon > Bool
 mightBeUnsaturatedTyCon :: TyCon > Bool
 isPromotedDataCon :: TyCon > Bool
 isPromotedDataCon_maybe :: TyCon > Maybe DataCon
 isKindTyCon :: TyCon > Bool
 isLiftedTypeKindTyConName :: Name > Bool
 isTauTyCon :: TyCon > Bool
 isFamFreeTyCon :: TyCon > Bool
 isDataTyCon :: TyCon > Bool
 isProductTyCon :: TyCon > Bool
 isDataProductTyCon_maybe :: TyCon > Maybe DataCon
 isDataSumTyCon_maybe :: TyCon > Maybe [DataCon]
 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)
 familyTyConInjectivityInfo :: TyCon > Injectivity
 isBuiltInSynFamTyCon_maybe :: TyCon > Maybe BuiltInSynFamily
 isUnliftedTyCon :: TyCon > Bool
 isGadtSyntaxTyCon :: TyCon > Bool
 isInjectiveTyCon :: TyCon > Role > Bool
 isGenerativeTyCon :: TyCon > Role > Bool
 isGenInjAlgRhs :: AlgTyConRhs > Bool
 isTyConAssoc :: TyCon > Bool
 tyConAssoc_maybe :: TyCon > Maybe Class
 isImplicitTyCon :: TyCon > Bool
 isTyConWithSrcDataCons :: TyCon > Bool
 isTcTyCon :: TyCon > Bool
 isTcLevPoly :: TyCon > Bool
 tyConName :: TyCon > Name
 tyConSkolem :: TyCon > Bool
 tyConKind :: TyCon > Kind
 tyConUnique :: TyCon > Unique
 tyConTyVars :: TyCon > [TyVar]
 tyConCType :: TyCon > Maybe CType
 tyConCType_maybe :: TyCon > Maybe CType
 tyConDataCons :: TyCon > [DataCon]
 tyConDataCons_maybe :: TyCon > Maybe [DataCon]
 tyConSingleDataCon_maybe :: TyCon > Maybe DataCon
 tyConSingleDataCon :: TyCon > DataCon
 tyConSingleAlgDataCon_maybe :: TyCon > Maybe DataCon
 tyConFamilySize :: TyCon > Int
 tyConStupidTheta :: TyCon > [PredType]
 tyConArity :: TyCon > Arity
 tyConRoles :: TyCon > [Role]
 tyConFlavour :: TyCon > String
 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
 famTcResVar :: TyCon > Maybe Name
 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 :: TyCon > FieldLabelEnv
 tyConRuntimeRepInfo :: TyCon > RuntimeRepInfo
 tyConBinders :: TyCon > [TyConBinder]
 tyConResKind :: TyCon > Kind
 tcTyConScopedTyVars :: TyCon > [TyVar]
 expandSynTyCon_maybe :: TyCon > [tyco] > Maybe ([(TyVar, tyco)], Type, [tyco])
 makeRecoveryTyCon :: TyCon > TyCon
 newTyConCo :: TyCon > CoAxiom Unbranched
 newTyConCo_maybe :: TyCon > Maybe (CoAxiom Unbranched)
 pprPromotionQuote :: TyCon > SDoc
 mkTyConKind :: [TyConBinder] > Kind > Kind
 type TyConRepName = Name
 tyConRepName_maybe :: TyCon > Maybe TyConRepName
 mkPrelTyConRepName :: Name > TyConRepName
 tyConRepModOcc :: Module > OccName > (Module, OccName)
 data PrimRep
 data PrimElemRep
 isVoidRep :: PrimRep > Bool
 isGcPtrRep :: PrimRep > Bool
 primRepSizeW :: DynFlags > PrimRep > Int
 primElemRepSizeB :: PrimElemRep > Int
 primRepIsFloat :: PrimRep > Maybe Bool
 data RecTcChecker
 initRecTc :: RecTcChecker
 checkRecTc :: RecTcChecker > TyCon > Maybe RecTcChecker
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.
data AlgTyConRhs #
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  
NewTyCon  Information about those 

visibleDataCons :: AlgTyConRhs > [DataCon] #
Both type classes as well as family instances imply implicit type constructors. These implicit type constructors refer to their parent structure (ie, the class or family from which they derive) using a type of the following form.
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 #
VanillaAlgTyCon TyConRepName  An ordinary type constructor has no parent. 
UnboxedAlgTyCon (Maybe TyConRepName)  An unboxed type constructor. The TyConRepName is a Maybe since 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 TyCoRep 
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 
isNoParent :: AlgTyConFlav > Bool #
data FamTyConFlav #
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 
data RuntimeRepInfo #
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.
NoRRI  an ordinary promoted data con 
RuntimeRep ([Type] > [PrimRep])  A constructor of 
VecCount Int  A constructor of 
VecElem PrimElemRep  A constructor of 
TyConBinder
type TyConBinder = TyVarBndr TyVar TyConBndrVis #
data TyConBndrVis #
Binary TyConBndrVis #  
Outputable tv => Outputable (TyVarBndr tv TyConBndrVis) #  
mkNamedTyConBinder :: ArgFlag > TyVar > TyConBinder #
mkNamedTyConBinders :: ArgFlag > [TyVar] > [TyConBinder] #
mkAnonTyConBinder :: TyVar > TyConBinder #
mkAnonTyConBinders :: [TyVar] > [TyConBinder] #
isNamedTyConBinder :: TyConBinder > Bool #
isVisibleTyConBinder :: TyVarBndr tv TyConBndrVis > Bool #
isInvisibleTyConBinder :: TyVarBndr tv TyConBndrVis > Bool #
Field labels
tyConFieldLabels :: TyCon > [FieldLabel] #
The labels for the fields of this particular TyCon
lookupTyConFieldLabel :: FieldLabelString > TyCon > Maybe FieldLabel #
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
. Notably, you have to
pass in the generic (in the XGenerics sense) information about the
type constructor  you can get hold of it easily (see Generics
module)
mkClassTyCon :: Name > [TyConBinder] > [Role] > AlgTyConRhs > Class > Name > TyCon #
Simpler specialization of mkAlgTyCon
for classes
mkFunTyCon :: Name > [TyConBinder] > Name > TyCon #
:: Name  
> [TyConBinder]  
> Kind  result kind, never levitypolymorphic 
> [Role]  
> TyCon 
Create an unlifted primitive TyCon
, such as Int#
.
Kind constructors
:: Name  
> [TyConBinder]  
> Kind  result kind 
> [Role]  
> TyCon 
Create a lifted primitive TyCon
such as RealWorld
:: Name  
> [TyConBinder]  
> Kind  Result kind of the 
> Arity  Arity of the tuple 
> DataCon  
> TupleSort  Whether the tuple is boxed or unboxed 
> AlgTyConFlav  
> TyCon 
:: Name  
> [TyConBinder]  
> Kind  Kind of the resulting 
> Arity  Arity of the sum 
> [TyVar] 

> [DataCon]  
> AlgTyConFlav  
> 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] > RuntimeRepInfo > TyCon #
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 
> Bool  Can this be unsaturated? 
> [TyVar]  Scoped type variables, see Note [TcTyCon] 
> TyCon 
Makes a tycon suitable for use during typechecking. The only real need for this is for printing error messages during a recursive type/class typechecking knot. It has a kind because TcErrors sometimes calls typeKind. See also Note [Kind checking recursive type and class declarations] in TcTyClsDecls.
Predicates on TyCons
isAlgTyCon :: TyCon > Bool #
Returns True
if the supplied TyCon
resulted from either a
data
or newtype
declaration
isVanillaAlgTyCon :: TyCon > Bool #
Returns True
for vanilla AlgTyCons  that is, those created
with a data
or newtype
declaration.
isClassTyCon :: TyCon > Bool #
Is this TyCon
that for a class instance?
isFamInstTyCon :: TyCon > Bool #
Is this TyCon
that for a data family instance?
isFunTyCon :: TyCon > Bool #
isPrimTyCon :: TyCon > Bool #
Does this TyCon
represent something that cannot be defined in Haskell?
isTupleTyCon :: TyCon > Bool #
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.
isUnboxedTupleTyCon :: TyCon > Bool #
Is this the TyCon
for an unboxed tuple?
isBoxedTupleTyCon :: TyCon > Bool #
Is this the TyCon
for a boxed tuple?
isUnboxedSumTyCon :: TyCon > Bool #
Is this the TyCon
for an unboxed sum?
isPromotedTupleTyCon :: TyCon > Bool #
Is this the TyCon
for a promoted tuple?
isTypeSynonymTyCon :: TyCon > Bool #
Is this a TyCon
representing a regular H98 type synonym (type
)?
mightBeUnsaturatedTyCon :: TyCon > Bool #
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 mightBeUnsaturatedTyCon on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable
isPromotedDataCon :: TyCon > Bool #
Is this a PromotedDataCon?
isPromotedDataCon_maybe :: TyCon > Maybe DataCon #
Retrieves the promoted DataCon if this is a PromotedDataCon;
isKindTyCon :: TyCon > Bool #
Is this tycon really meant for use at the kind level? That is, should it be permitted without XDataKinds?
isLiftedTypeKindTyConName :: Name > Bool #
isTauTyCon :: TyCon > Bool #
isFamFreeTyCon :: TyCon > Bool #
isDataTyCon :: TyCon > Bool #
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
isProductTyCon :: TyCon > Bool #
isDataSumTyCon_maybe :: TyCon > Maybe [DataCon] #
isEnumerationTyCon :: TyCon > Bool #
Is this an algebraic TyCon
which is just an enumeration of values?
isNewTyCon :: TyCon > Bool #
Is this TyCon
that for a newtype
isAbstractTyCon :: TyCon > Bool #
Test if the TyCon
is algebraic but abstract (invisible data constructors)
isFamilyTyCon :: TyCon > Bool #
Is this a TyCon
, synonym or otherwise, that defines a family?
isOpenFamilyTyCon :: TyCon > Bool #
Is this a TyCon
, synonym or otherwise, that defines a family with
instances?
isTypeFamilyTyCon :: TyCon > Bool #
Is this a synonym TyCon
that can have may have further instances appear?
isDataFamilyTyCon :: TyCon > Bool #
Is this a synonym TyCon
that can have may have further instances appear?
isOpenTypeFamilyTyCon :: TyCon > Bool #
Is this an open type family TyCon?
isClosedSynFamilyTyConWithAxiom_maybe :: TyCon > Maybe (CoAxiom Branched) #
Is this a nonempty closed type family? Returns Nothing
for
abstract or empty closed families.
familyTyConInjectivityInfo :: TyCon > Injectivity #
Try to read the injectivity information from a FamilyTyCon. For every other TyCon this function panics.
isUnliftedTyCon :: TyCon > Bool #
isGadtSyntaxTyCon :: TyCon > Bool #
Is this an algebraic TyCon
declared with the GADT syntax?
isInjectiveTyCon :: TyCon > Role > Bool #
isInjectiveTyCon
is true of TyCon
s for which this property holds
(where X is the role passed in):
If (T a1 b1 c1) ~X (T a2 b2 c2), then (a1 ~X1 a2), (b1 ~X2 b2), and (c1 ~X3 c2)
(where X1, X2, and X3, are the roles given by tyConRolesX tc X)
See also Note [Decomposing equality] in TcCanonical
isGenerativeTyCon :: TyCon > Role > Bool #
isGenerativeTyCon
is true of TyCon
s for which this property holds
(where X is the role passed in):
If (T tys ~X t), then (t's head ~X T).
See also Note [Decomposing equality] in TcCanonical
isGenInjAlgRhs :: AlgTyConRhs > Bool #
Is this an AlgTyConRhs
of a TyCon
that is generative and injective
with respect to representational equality?
isTyConAssoc :: TyCon > Bool #
tyConAssoc_maybe :: TyCon > Maybe Class #
isImplicitTyCon :: TyCon > Bool #
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 tupeles are wiredin and implicit, but constraint tuples are not)
isTyConWithSrcDataCons :: TyCon > Bool #
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.
isTcLevPoly :: TyCon > Bool #
Could this TyCon ever be levitypolymorphic when fully applied? True is safe. False means we're sure. Does only a quick check based on the TyCon's category. Precondition: The fullyapplied TyCon has kind (TYPE blah)
Extracting information out of TyCons
tyConSkolem :: TyCon > Bool #
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 #
A Unique of this TyCon. Invariant: identical to Unique of Name stored in tyConName field.
tyConTyVars :: TyCon > [TyVar] #
TyVar binders
tyConCType :: TyCon > Maybe CType #
The C type that should be used for this type when using the FFI and CAPI
tyConCType_maybe :: TyCon > Maybe CType #
tyConDataCons :: TyCon > [DataCon] #
As tyConDataCons_maybe
, but returns the empty list of constructors if no
constructors could be found
tyConDataCons_maybe :: TyCon > Maybe [DataCon] #
tyConSingleDataCon_maybe :: TyCon > Maybe DataCon #
If the given TyCon
has a single data constructor, i.e. it is a data
type with one alternative, a tuple type or a newtype
then that constructor
is returned. If the TyCon
has more than one constructor, or represents a
primitive or function type constructor then Nothing
is returned. In any
other case, the function panics
tyConSingleDataCon :: TyCon > DataCon #
tyConFamilySize :: TyCon > Int #
tyConStupidTheta :: TyCon > [PredType] #
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 ...
tyConArity :: TyCon > Arity #
Arity
tyConRoles :: TyCon > [Role] #
Get the list of roles for the type parameters of a TyCon
tyConFlavour :: TyCon > String #
tyConTuple_maybe :: TyCon > Maybe TupleSort #
tyConClass_maybe :: TyCon > Maybe Class #
If this TyCon
is that for a class instance, return the class it is for.
Otherwise returns Nothing
tyConFamInst_maybe :: TyCon > Maybe (TyCon, [Type]) #
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) #
tyConFamilyResVar_maybe :: TyCon > Maybe Name #
Extract type variable naming the result of injective type family
synTyConDefn_maybe :: TyCon > Maybe ([TyVar], Type) #
Extract the TyVar
s bound by a vanilla type synonym
and the corresponding (unsubstituted) right hand side.
synTyConRhs_maybe :: TyCon > Maybe Type #
Extract the information pertaining to the right hand side of a type synonym
(type
) declaration.
famTyConFlav_maybe :: TyCon > Maybe FamTyConFlav #
Extract the flavour of a type family (with all the extra information that it carries)
famTcResVar :: TyCon > Maybe Name #
Name of result type variable, used for prettyprinting with showiface and for reifying TyCon in Template Haskell
algTyConRhs :: TyCon > AlgTyConRhs #
Extract an AlgTyConRhs
with information about data constructors from an
algebraic or tuple TyCon
. Panics for any other sort of TyCon
newTyConRhs :: TyCon > ([TyVar], Type) #
newTyConEtadArity :: TyCon > Int #
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.
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 :: TyCon > FieldLabelEnv #
Maps a label to information about the field
tyConRuntimeRepInfo :: TyCon > RuntimeRepInfo #
Extract any RuntimeRepInfo
from this TyCon
tyConBinders :: TyCon > [TyConBinder] #
Full binders
tyConResKind :: TyCon > Kind #
Result kind
tcTyConScopedTyVars :: TyCon > [TyVar] #
Scoped tyvars over the tycon's body. See Note [TcTyCon]
Manipulating TyCons
:: TyCon  
> [tyco]  Arguments to 
> Maybe ([(TyVar, tyco)], Type, [tyco])  Returns a 
Expand a type synonym application, if any
makeRecoveryTyCon :: TyCon > TyCon #
Make an fake, recovery TyCon
from an existing one.
Used when recovering from errors
newTyConCo :: TyCon > CoAxiom Unbranched #
newTyConCo_maybe :: TyCon > Maybe (CoAxiom Unbranched) #
pprPromotionQuote :: TyCon > SDoc #
mkTyConKind :: [TyConBinder] > Kind > Kind #
Runtime type representation
type TyConRepName = Name #
mkPrelTyConRepName :: Name > TyConRepName #
Make a Name
for the Typeable
representation of the given wiredin type
tyConRepModOcc :: Module > OccName > (Module, OccName) #
The name (and defining module) for the Typeable representation (TyCon) of a type constructor.
See Note [Grand plan for Typeable] in TcTypeable
in TcTypeable.
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.
VoidRep  
LiftedRep  
UnliftedRep  Unlifted pointer 
IntRep  Signed, wordsized value 
WordRep  Unsigned, wordsized value 
Int64Rep  Signed, 64 bit value (with 32bit words only) 
Word64Rep  Unsigned, 64 bit value (with 32bit words only) 
AddrRep  A pointer, but not to a Haskell value (use '(Un)liftedRep') 
FloatRep  
DoubleRep  
VecRep Int PrimElemRep  A vector 
data PrimElemRep #
isGcPtrRep :: PrimRep > Bool #
primElemRepSizeB :: PrimElemRep > Int #
primRepIsFloat :: PrimRep > Maybe Bool #
Return if Rep stands for floating type, returns Nothing for vector types.
Recursion breaking
data RecTcChecker #
checkRecTc :: RecTcChecker > TyCon > Maybe RecTcChecker #