GHC.Core.TyCon

Main TyCon data types

data TyCon

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

Data TyCon

Defined in GHC.Core.TyCon

Methods

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

toConstr :: TyCon -> Constr

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

NamedThing TyCon

Defined in GHC.Core.TyCon

Methods

getOccName :: TyCon -> OccName

getName :: TyCon -> Name

Uniquable TyCon

Defined in GHC.Core.TyCon

Methods

getUnique :: TyCon -> Unique

Outputable TyCon

Defined in GHC.Core.TyCon

Methods

ppr :: TyCon -> SDoc

Eq TyCon

Defined in GHC.Core.TyCon

Methods

(==) :: TyCon -> TyCon -> Bool

(/=) :: TyCon -> TyCon -> Bool

data AlgTyConRhs

Represents right-hand-sides of TyCons for algebraic types

Constructors

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 TyCons derived from a data declaration. This includes data types with no constructors at all.

Fields

• data_cons :: [DataCon]

  The data type constructors; can be empty if the user declares the type to have no constructors

  INVARIANT: Kept in order of increasing DataCon tag (see the tag assignment in mkTyConTagMap)

• data_cons_size :: Int

  Cached value: length data_cons

• is_enum :: Bool

  Cached value: is this an enumeration type? See Note [Enumeration types]

• is_type_data :: Bool
• data_fixed_lev :: Bool

  True if the data type constructor has a known, fixed levity when fully applied to its arguments, False otherwise.

  This can only be False with UnliftedDatatypes, e.g.

  data A :: TYPE (BoxedRep l) where { MkA :: Int -> A }

  This boolean is cached to make it cheaper to check for levity and representation-polymorphism in tcHasFixedRuntimeRep.

TupleTyCon

Fields

• data_con :: DataCon

  The unique constructor for the newtype. It has no existentials

• tup_sort :: TupleSort

  Is this a boxed, unboxed or constraint tuple?

SumTyCon

An unboxed sum type.

Fields

• data_cons :: [DataCon]

  The data type constructors; can be empty if the user declares the type to have no constructors

  INVARIANT: Kept in order of increasing DataCon tag (see the tag assignment in mkTyConTagMap)

• data_cons_size :: Int

  Cached value: length data_cons

NewTyCon

Information about those TyCons derived from a newtype declaration

Fields

• data_con :: DataCon

  The unique constructor for the newtype. It has no existentials

• nt_rhs :: Type

  Cached value: the argument type of the constructor, which is just the representation type of the TyCon (remember that newtypes do not exist at runtime so need a different representation type).

  The free TyVars of this type are the tyConTyVars from the corresponding TyCon

• nt_etad_rhs :: ([TyVar], Type)

  Same as the nt_rhs, but this time eta-reduced. Hence the list of TyVars in this field may be shorter than the declared arity of the TyCon.

• nt_co :: CoAxiom Unbranched
• nt_fixed_rep :: Bool

  True if the newtype has a known, fixed representation when fully applied to its arguments, False otherwise. This can only ever be False with UnliftedNewtypes.

  Example:

  newtype N (a :: TYPE r) = MkN a

  Invariant: nt_fixed_rep nt = tcHasFixedRuntimeRep (nt_rhs nt)

  This boolean is cached to make it cheaper to check if a variable binding is representation-polymorphic in tcHasFixedRuntimeRep.

visibleDataCons :: AlgTyConRhs -> [DataCon]

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!

data AlgTyConFlav

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

Constructors

VanillaAlgTyCon TyConRepName

An ordinary algebraic type constructor. This includes unlifted and representation-polymorphic 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 tyConTyVars of the current TyCon (not the family one). INVARIANT: the number of types matches the arity of the family TyCon

3) A CoTyCon identifying the representation type with the type instance family

Instances

Outputable AlgTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: AlgTyConFlav -> SDoc

isNoParent :: AlgTyConFlav -> Bool

data FamTyConFlav

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

Constructors

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. type family F x y :: Type -> Type

ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))

A closed type synonym family e.g. type family F x where { F Int = Bool }

AbstractClosedSynFamilyTyCon

A closed type synonym family declared in an hs-boot file with type family F a where ..

BuiltInSynFamTyCon BuiltInSynFamily

Built-in type family used by the TypeNats solver

Instances

Outputable FamTyConFlav

Defined in GHC.Core.TyCon

Methods

ppr :: FamTyConFlav -> SDoc

data Role

See Note [Roles] in GHC.Core.Coercion

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

Constructors

Nominal

Representational

Phantom

Instances

Data Role

Defined in Language.Haskell.Syntax.Basic

Methods

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

toConstr :: Role -> Constr

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

Binary Role

Defined in GHC.Core.Coercion.Axiom

Methods

put_ :: BinHandle -> Role -> IO ()

put :: BinHandle -> Role -> IO (Bin Role)

get :: BinHandle -> IO Role

Outputable Role

Defined in GHC.Core.Coercion.Axiom

Methods

ppr :: Role -> SDoc

Eq Role

Defined in Language.Haskell.Syntax.Basic

Methods

(==) :: Role -> Role -> Bool

(/=) :: Role -> Role -> Bool

Ord Role

Defined in Language.Haskell.Syntax.Basic

Methods

compare :: Role -> Role -> Ordering

(<) :: Role -> Role -> Bool

(<=) :: Role -> Role -> Bool

(>) :: Role -> Role -> Bool

(>=) :: Role -> Role -> Bool

max :: Role -> Role -> Role

min :: Role -> Role -> Role

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcAnn NoEpAnns

type Anno (Maybe Role)

Defined in GHC.Hs.Decls

type Anno (Maybe Role) = SrcAnn NoEpAnns

data Injectivity

Constructors

NotInjective

Injective [Bool]

Instances

Binary Injectivity

Defined in GHC.Core.TyCon

Methods

put_ :: BinHandle -> Injectivity -> IO ()

put :: BinHandle -> Injectivity -> IO (Bin Injectivity)

get :: BinHandle -> IO Injectivity

Eq Injectivity

Defined in GHC.Core.TyCon

Methods

(==) :: Injectivity -> Injectivity -> Bool

(/=) :: Injectivity -> Injectivity -> Bool

data PromDataConInfo

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

Constructors

NoPromInfo

an ordinary promoted data con

RuntimeRep ([Type] -> [PrimRep])

A constructor of RuntimeRep. The argument to the function should be the list of arguments to the promoted datacon.

VecCount Int

A constructor of VecCount

VecElem PrimElemRep

A constructor of VecElem

Levity Levity

A constructor of Levity

data TyConFlavour tc

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

Constructors

ClassFlavour

TupleFlavour Boxity

SumFlavour

DataTypeFlavour

NewtypeFlavour

AbstractTypeFlavour

OpenFamilyFlavour TypeOrData (Maybe tc)

ClosedTypeFamilyFlavour

TypeSynonymFlavour

BuiltInTypeFlavour

e.g., the (->) TyCon.

PromotedDataConFlavour

Instances

Functor TyConFlavour

Defined in GHC.Types.Basic

Methods

fmap :: (a -> b) -> TyConFlavour a -> TyConFlavour b

(<$) :: a -> TyConFlavour b -> TyConFlavour a

Data tc => Data (TyConFlavour tc)

Defined in GHC.Types.Basic

Methods

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)

NFData tc => NFData (TyConFlavour tc)

Defined in GHC.Types.Basic

Methods

rnf :: TyConFlavour tc -> ()

Outputable (TyConFlavour tc)

Defined in GHC.Types.Basic

Methods

ppr :: TyConFlavour tc -> SDoc

Eq tc => Eq (TyConFlavour tc)

Defined in GHC.Types.Basic

Methods

(==) :: TyConFlavour tc -> TyConFlavour tc -> Bool

(/=) :: TyConFlavour tc -> TyConFlavour tc -> Bool

TyConBinder

type TyConBinder = VarBndr TyVar TyConBndrVis

data TyConBndrVis

Constructors

NamedTCB ForAllTyFlag

A named, forall-bound variable (invisible or not)

AnonTCB

an ordinary, visible type argument

Instances

Binary TyConBndrVis

Defined in GHC.Core.TyCon

Methods

put_ :: BinHandle -> TyConBndrVis -> IO ()

put :: BinHandle -> TyConBndrVis -> IO (Bin TyConBndrVis)

get :: BinHandle -> IO TyConBndrVis

Outputable TyConBndrVis

Defined in GHC.Core.TyCon

Methods

ppr :: TyConBndrVis -> SDoc

OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis)

Defined in GHC.Core.TyCon

Methods

ppr :: VarBndr tv TyConBndrVis -> SDoc

mkNamedTyConBinder :: ForAllTyFlag -> TyVar -> TyConBinder

mkNamedTyConBinders :: ForAllTyFlag -> [TyVar] -> [TyConBinder]

mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder

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

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

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

mkAlgTyCon

Arguments

:: Name

-> [TyConBinder]

Binders of the TyCon

-> 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 algTcStupidTheta

-> AlgTyConRhs

Information about data constructors

-> AlgTyConFlav

What flavour is it? (e.g. vanilla, type family)

-> Bool

Was the TyCon declared with GADT syntax?

-> TyCon

This is the making of an algebraic TyCon.

mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon

Simpler specialization of mkAlgTyCon for classes

mkPrimTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind Must answer True to isFixedRuntimeRepKind (i.e., no representation polymorphism). (If you need a representation-polymorphic PrimTyCon, change tcHasFixedRuntimeRep, marshalablePrimTyCon, reifyTyCon for PrimTyCons.)

-> [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.

mkTupleTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

Result kind of the TyCon

-> DataCon

-> TupleSort

Whether the tuple is boxed or unboxed

-> AlgTyConFlav

-> TyCon

mkSumTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

Kind of the resulting TyCon

-> [DataCon]

-> AlgTyConFlav

-> TyCon

mkDataTyConRhs :: [DataCon] -> AlgTyConRhs

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

mkLevPolyDataTyConRhs

Arguments

:: Bool

whether the DataCon has a fixed levity

-> 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 levity-polymorphic datatype (with UnliftedDatatypes).

mkSynonymTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> Type

-> Bool

-> Bool

-> Bool

-> Bool

-> TyCon

Create a type synonym TyCon

mkFamilyTyCon

Arguments

:: 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

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

mkTcTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind only

-> [(Name, TcTyVar)]

Scoped type variables;

-> Bool

Is this TcTyCon generalised already?

-> TyConFlavour TyCon

What sort of TyCon this represents

-> TyCon

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

noTcTyConScopedTyVars :: [(Name, TcTyVar)]

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

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?

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?

isLiftedAlgTyCon :: TyCon -> Bool

isTypeSynonymTyCon :: TyCon -> Bool

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

tyConMustBeSaturated :: 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 tyConMustBeSaturated 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;

isDataKindsPromotedDataCon :: TyCon -> Bool

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

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

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

isForgetfulSynTyCon :: TyCon -> Bool

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

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

isTypeDataTyCon :: TyCon -> Bool

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

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 type family TyCon (whether open or closed)?

isDataFamilyTyCon :: TyCon -> Bool

Is this a data family TyCon?

isOpenTypeFamilyTyCon :: TyCon -> Bool

Is this an open type family TyCon?

isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)

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

tyConInjectivityInfo :: TyCon -> Injectivity

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

isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily

isGadtSyntaxTyCon :: TyCon -> Bool

Is this an algebraic TyCon declared with the GADT syntax?

isInjectiveTyCon :: TyCon -> Role -> Bool

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 :: TyCon -> Role -> Bool

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)

isGenInjAlgRhs :: AlgTyConRhs -> Bool

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

isTyConAssoc :: TyCon -> Bool

Is this TyCon for an associated type?

tyConAssoc_maybe :: TyCon -> Maybe TyCon

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

tyConFlavourAssoc_maybe :: TyConFlavour tc -> Maybe tc

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

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 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)

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.

isTcTyCon :: TyCon -> Bool

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

setTcTyConKind :: TyCon -> Kind -> TyCon

tcHasFixedRuntimeRep :: TyCon -> Bool

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]

isConcreteTyCon :: TyCon -> Bool

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

Extracting information out of TyCons

tyConName :: TyCon -> Name

Name of the constructor

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]

tyConKind :: TyCon -> Kind

Kind of this TyCon

tyConUnique :: TyCon -> Unique

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

tyConTyVars :: TyCon -> [TyVar]

TyVar binders

tyConVisibleTyVars :: TyCon -> [TyVar]

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]

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)

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.

tyConSingleDataCon :: TyCon -> DataCon

Like tyConSingleDataCon_maybe, but panics if Nothing.

tyConAlgDataCons_maybe :: TyCon -> Maybe [DataCon]

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

Like tyConSingleDataCon_maybe, but returns Nothing for newtypes.

tyConFamilySize :: TyCon -> Int

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

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 .... See Note [The stupid context] in GHC.Core.DataCon.

tyConArity :: TyCon -> Arity

Arity

tyConNullaryTy :: TyCon -> Type

A pre-allocated TyConApp tycon []

mkTyConTy :: TyCon -> Type

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

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

tyConFlavour :: TyCon -> TyConFlavour TyCon

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

tyConATs :: TyCon -> [TyCon]

Return the associated types of the TyCon, if any

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)

tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)

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

tyConFamilyResVar_maybe :: TyCon -> Maybe Name

Extract type variable naming the result of injective type family

synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)

Extract the TyVars 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)

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)

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

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

newTyConEtadRhs :: TyCon -> ([TyVar], Type)

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

unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)

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.

unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)

newTyConDataCon_maybe :: TyCon -> Maybe DataCon

algTcFields :: TyConDetails -> FieldLabelEnv

Maps a label to information about the field

tyConPromDataConInfo :: TyCon -> PromDataConInfo

Extract any RuntimeRepInfo from this TyCon

tyConBinders :: TyCon -> [TyConBinder]

Full binders

tyConResKind :: TyCon -> Kind

Result kind

tyConInvisTVBinders :: [TyConBinder] -> [InvisTVBinder]

tcTyConScopedTyVars :: TyCon -> [(Name, TcTyVar)]

isMonoTcTyCon :: TyCon -> Bool

tyConHasClosedResKind :: TyCon -> Bool

mkTyConTagMap :: TyCon -> NameEnv ConTag

Manipulating TyCons

data ExpandSynResult tyco

Constructors

NoExpansion

ExpandsSyn [(TyVar, tyco)] Type [tyco]

expandSynTyCon_maybe

Arguments

:: TyCon

-> [tyco]

Arguments to TyCon

-> ExpandSynResult tyco

Returns a TyVar substitution, the body type of the synonym (not yet substituted) and any arguments remaining from the application ^ Expand a type synonym application Return Nothing if the TyCon is not a synonym, or if not enough arguments are supplied

newTyConCo :: TyCon -> CoAxiom Unbranched

newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)

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

pprPromotionQuote :: TyCon -> SDoc

mkTyConKind :: [TyConBinder] -> Kind -> Kind

Predicated on TyConFlavours

tcFlavourIsOpen :: TyConFlavour tc -> Bool

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

Runtime type representation

type TyConRepName = Name

tyConRepName_maybe :: TyCon -> Maybe TyConRepName

mkPrelTyConRepName :: Name -> TyConRepName

Make a Name for the Typeable representation of the given wired-in 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 GHC.Tc.Instance.Typeable.

Primitive representations of Types

data PrimRep

A PrimRep is an abstraction of a type. It contains information that the code generator needs in order to pass arguments, return results, and store values of this type. See also Note [RuntimeRep and PrimRep] in GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.

Constructors

VoidRep

BoxedRep !(Maybe Levity)

Boxed, heap value

Int8Rep

Signed, 8-bit value

Int16Rep

Signed, 16-bit value

Int32Rep

Signed, 32-bit value

Int64Rep

Signed, 64 bit value

IntRep

Signed, word-sized value

Word8Rep

Unsigned, 8 bit value

Word16Rep

Unsigned, 16 bit value

Word32Rep

Unsigned, 32 bit value

Word64Rep

Unsigned, 64 bit value

WordRep

Unsigned, word-sized value

AddrRep

A pointer, but not to a Haskell value (use BoxedRep)

FloatRep

DoubleRep

VecRep Int PrimElemRep

A vector

Instances

Data PrimRep

Defined in GHC.Core.TyCon

Methods

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

Defined in GHC.Core.TyCon

Methods

showsPrec :: Int -> PrimRep -> ShowS

show :: PrimRep -> String

showList :: [PrimRep] -> ShowS

Binary PrimRep

Defined in GHC.Core.TyCon

Methods

put_ :: BinHandle -> PrimRep -> IO ()

put :: BinHandle -> PrimRep -> IO (Bin PrimRep)

get :: BinHandle -> IO PrimRep

Outputable PrimRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimRep -> SDoc

Eq PrimRep

Defined in GHC.Core.TyCon

Methods

(==) :: PrimRep -> PrimRep -> Bool

(/=) :: PrimRep -> PrimRep -> Bool

Ord PrimRep

Defined in GHC.Core.TyCon

Methods

compare :: PrimRep -> PrimRep -> Ordering

(<) :: PrimRep -> PrimRep -> Bool

(<=) :: PrimRep -> PrimRep -> Bool

(>) :: PrimRep -> PrimRep -> Bool

(>=) :: PrimRep -> PrimRep -> Bool

max :: PrimRep -> PrimRep -> PrimRep

min :: PrimRep -> PrimRep -> PrimRep

data PrimElemRep

Constructors

Int8ElemRep

Int16ElemRep

Int32ElemRep

Int64ElemRep

Word8ElemRep

Word16ElemRep

Word32ElemRep

Word64ElemRep

FloatElemRep

DoubleElemRep

Instances

Data PrimElemRep

Defined in GHC.Core.TyCon

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrimElemRep -> c PrimElemRep

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrimElemRep

toConstr :: PrimElemRep -> Constr

dataTypeOf :: PrimElemRep -> DataType

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c PrimElemRep)

dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c PrimElemRep)

gmapT :: (forall b. Data b => b -> b) -> PrimElemRep -> PrimElemRep

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> PrimElemRep -> r

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> PrimElemRep -> r

gmapQ :: (forall d. Data d => d -> u) -> PrimElemRep -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> PrimElemRep -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> PrimElemRep -> m PrimElemRep

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> PrimElemRep -> m PrimElemRep

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> PrimElemRep -> m PrimElemRep

Enum PrimElemRep

Defined in GHC.Core.TyCon

Methods

succ :: PrimElemRep -> PrimElemRep

pred :: PrimElemRep -> PrimElemRep

toEnum :: Int -> PrimElemRep

fromEnum :: PrimElemRep -> Int

enumFrom :: PrimElemRep -> [PrimElemRep]

enumFromThen :: PrimElemRep -> PrimElemRep -> [PrimElemRep]

enumFromTo :: PrimElemRep -> PrimElemRep -> [PrimElemRep]

enumFromThenTo :: PrimElemRep -> PrimElemRep -> PrimElemRep -> [PrimElemRep]

Show PrimElemRep

Defined in GHC.Core.TyCon

Methods

showsPrec :: Int -> PrimElemRep -> ShowS

show :: PrimElemRep -> String

showList :: [PrimElemRep] -> ShowS

Binary PrimElemRep

Defined in GHC.Core.TyCon

Methods

put_ :: BinHandle -> PrimElemRep -> IO ()

put :: BinHandle -> PrimElemRep -> IO (Bin PrimElemRep)

get :: BinHandle -> IO PrimElemRep

Outputable PrimElemRep

Defined in GHC.Core.TyCon

Methods

ppr :: PrimElemRep -> SDoc

Eq PrimElemRep

Defined in GHC.Core.TyCon

Methods

(==) :: PrimElemRep -> PrimElemRep -> Bool

(/=) :: PrimElemRep -> PrimElemRep -> Bool

Ord PrimElemRep

Defined in GHC.Core.TyCon

Methods

compare :: PrimElemRep -> PrimElemRep -> Ordering

(<) :: PrimElemRep -> PrimElemRep -> Bool

(<=) :: PrimElemRep -> PrimElemRep -> Bool

(>) :: PrimElemRep -> PrimElemRep -> Bool

(>=) :: PrimElemRep -> PrimElemRep -> Bool

max :: PrimElemRep -> PrimElemRep -> PrimElemRep

min :: PrimElemRep -> PrimElemRep -> PrimElemRep

data Levity

Constructors

Lifted

Unlifted

Instances

Data Levity

Defined in GHC.Types.Basic

Methods

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

Defined in GHC.Types.Basic

Methods

showsPrec :: Int -> Levity -> ShowS

show :: Levity -> String

showList :: [Levity] -> ShowS

Binary Levity

Defined in GHC.Types.Basic

Methods

put_ :: BinHandle -> Levity -> IO ()

put :: BinHandle -> Levity -> IO (Bin Levity)

get :: BinHandle -> IO Levity

Outputable Levity

Defined in GHC.Types.Basic

Methods

ppr :: Levity -> SDoc

Eq Levity

Defined in GHC.Types.Basic

Methods

(==) :: Levity -> Levity -> Bool

(/=) :: Levity -> Levity -> Bool

Ord Levity

Defined in GHC.Types.Basic

Methods

compare :: Levity -> Levity -> Ordering

(<) :: Levity -> Levity -> Bool

(<=) :: Levity -> Levity -> Bool

(>) :: Levity -> Levity -> Bool

(>=) :: Levity -> Levity -> Bool

max :: Levity -> Levity -> Levity

min :: Levity -> Levity -> Levity

primElemRepToPrimRep :: PrimElemRep -> PrimRep

isVoidRep :: PrimRep -> Bool

isGcPtrRep :: PrimRep -> Bool

primRepSizeB :: Platform -> PrimRep -> Int

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.

primElemRepSizeB :: Platform -> PrimElemRep -> Int

primRepIsFloat :: PrimRep -> Maybe Bool

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

primRepsCompatible :: Platform -> [PrimRep] -> [PrimRep] -> Bool

primRepCompatible :: Platform -> PrimRep -> PrimRep -> Bool

primRepIsWord :: PrimRep -> Bool

primRepIsInt :: PrimRep -> Bool