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

Represents right-hand-sides of TyCons for algebraic types

Extract those DataCons 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!

Describes the flavour of an algebraic type constructor. For classes and data families, this flavour includes a reference to the parent TyCon.

Information pertaining to the expansion of a type synonym (type)

See Note [Roles] in GHC.Core.Coercion

Order of constructors matters: the Ord instance coincides with the *super*typing relation on roles.

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 known-key every time. See also Note [Getting from RuntimeRep to PrimRep] in GHC.Types.RepType

Paints a picture of what a TyCon represents, in broad strokes. This is used towards more informative error messages.

Make a Required TyConBinder. It chooses between NamedTCB and AnonTCB based on whether the tv is mentioned in the dependent set

The labels for the fields of this particular TyCon

Look up a field label belonging to this TyCon

This is the making of an algebraic TyCon.

Simpler specialization of mkAlgTyCon for classes

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.

Create an AlgTyConRhs from the data constructors.

Use mkLevPolyDataConRhs if the datatype can be levity-polymorphic or if it comes from a "data type" declaration

Create an AlgTyConRhs from the data constructors, for a potentially levity-polymorphic datatype (with UnliftedDatatypes).

Create a type synonym TyCon

Create a type family TyCon

Create a promoted data constructor TyCon Somewhat dodgily, we give it the same Name as the data constructor itself; when we pretty-print the TyCon we add a quote; see the Outputable TyCon instance

Makes a tycon suitable for use during type-checking. It stores a variety of details about the definition of the TyCon, but no right-hand side. It lives only during the type-checking of a mutually-recursive group of tycons; it is then zonked to a proper TyCon in zonkTcTyCon. See Note [TcTyCon, MonoTcTyCon, and PolyTcTyCon] in GHC.Tc.TyCl

No scoped type variables (to be used with mkTcTyCon).

Returns True if the supplied TyCon resulted from either a data or newtype declaration

Returns True for vanilla AlgTyCons -- that is, those created with a data or newtype declaration.

Is this TyCon that for a class instance?

Is this TyCon that for a data family instance?

Does this TyCon represent something that cannot be defined in Haskell?

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.

Is this the TyCon for an unboxed tuple?

Is this the TyCon for a boxed tuple?

Is this the TyCon for an unboxed sum?

Is this the TyCon for a promoted tuple?

Is this a TyCon representing a regular H98 type synonym (type)?

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

Is this a PromotedDataCon?

Retrieves the promoted DataCon if this is a PromotedDataCon;

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

Is this tycon really meant for use at the kind level? That is, should it be permitted without -XDataKinds?

Is this tycon neither a type family nor a synonym that expands to a type family?

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.

Returns True for data types that are definitely represented by heap-allocated constructors. These are scrutinised by Core-level case expressions, and they get info tables allocated for them.

Generally, the function will be true for all data types and false for newtypes, unboxed tuples, unboxed sums and type family TyCons. But it is not guaranteed to return True in all cases that it could.

NB: for a data type family, only the instance TyCons get an info table. The family declaration TyCon does not

Was this TyCon declared as "type data"? See Note [Type data declarations] in GHC.Rename.Module.

Is this an algebraic TyCon which is just an enumeration of values?

Is this TyCon that for a newtype

Test if the TyCon is algebraic but abstract (invisible data constructors)

Is this a TyCon, synonym or otherwise, that defines a family?

Is this a TyCon, synonym or otherwise, that defines a family with instances?

Is this a type family TyCon (whether open or closed)?

Is this a data family TyCon?

Is this an open type family TyCon?

Is this a non-empty closed type family? Returns Nothing for abstract or empty closed families.

tyConInjectivityInfo tc returns Injective is if tc is an injective tycon (where is states for which tyConBinders tc is injective), or NotInjective otherwise.

Is this an algebraic TyCon declared with the GADT syntax?

isInjectiveTyCon is true of TyCons 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 is true of TyCons 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)

Is this an AlgTyConRhs of a TyCon that is generative and injective with respect to representational equality?

Is this TyCon for an associated type?

Get the enclosing class TyCon (if there is one) for the given TyCon.

Get the enclosing class TyCon (if there is one) for the given TyConFlavour

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 re-constructed 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 wired-in name (namely: boxed and unboxed tuples are wired-in and implicit, but constraint tuples are not)

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.

Is this a TcTyCon? (That is, one only used during type-checking?)

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 [Representation-polymorphic TyCons]

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

Name of the constructor

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]

Kind of this TyCon

A Unique of this TyCon. Invariant: identical to Unique of Name stored in tyConName field.

TyVar binders

As tyConDataCons_maybe, but returns the empty list of constructors if no constructors could be found

Determine the DataCons originating from the given TyCon, if the TyCon is the sort that can have any constructors (note: this does not include abstract algebraic types)

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.

Like tyConSingleDataCon_maybe, but panics if Nothing.

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.

Like tyConSingleDataCon_maybe, but returns Nothing for newtypes.

Determine the number of value constructors a TyCon has. Panics if the TyCon is not algebraic or a tuple

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.

Arity

A pre-allocated TyConApp tycon []

(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!

The role for each type variable This list has length = tyConArity See also Note [TyCon Role signatures]

If this TyCon is that for a class instance, return the class it is for. Otherwise returns Nothing

Return the associated types of the TyCon, if any

If this TyCon is that of a data family instance, return the family in question and the instance types. Otherwise, return Nothing

If this TyCon is that of a data family instance, return a TyCon which represents a coercion identifying the representation type with the type instance family. Otherwise, return Nothing

Extract type variable naming the result of injective type family

Extract the TyVars bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

Extract the information pertaining to the right hand side of a type synonym (type) declaration.

Extract the flavour of a type family (with all the extra information that it carries)

Extract an AlgTyConRhs with information about data constructors from an algebraic or tuple TyCon. Panics for any other sort of TyCon

Extract the bound type variables and type expansion of a type synonym TyCon. Panics if the TyCon is not a synonym

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 eta-contracted.

Extract the bound type variables and type expansion of an eta-contracted type synonym TyCon. Panics if the TyCon is not a synonym

Take a TyCon apart into the TyVars it scopes over, the Type it expands into, and (possibly) a coercion from the representation type to the newtype. Returns Nothing if this is not possible.

Maps a label to information about the field

Extract any RuntimeRepInfo from this TyCon

Full binders

Result kind

Extracts the newtype coercion from such a TyCon, which can be used to construct something with the newtypes type from its representation type (right hand side). If the supplied TyCon is not a newtype, returns Nothing

Is this flavour of TyCon an open type family or a data family?

Make a Name for the Typeable representation of the given wired-in type

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.

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.

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 64-bit arch will be equal to 1 word. See also mkVirtHeapOffsetsWithPadding for details of how data fields are laid out.

Return if Rep stands for floating type, returns Nothing for vector types.