ghc-9.0.2: The GHC API
Safe HaskellSafe-Inferred
LanguageHaskell2010

GHC.Core.TyCon

Synopsis

Main TyCon data types

data TyCon Source #

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.

Instances

Instances details
Data TyCon Source # 
Instance details

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 Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCon Source #

toConstr :: TyCon -> Constr Source #

dataTypeOf :: TyCon -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCon) Source #

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

gmapT :: (forall b. Data b => b -> b) -> TyCon -> TyCon Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> TyCon -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCon -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon Source #

NamedThing TyCon Source # 
Instance details

Defined in GHC.Core.TyCon

Uniquable TyCon Source # 
Instance details

Defined in GHC.Core.TyCon

Outputable TyCon Source # 
Instance details

Defined in GHC.Core.TyCon

Eq TyCon Source # 
Instance details

Defined in GHC.Core.TyCon

Methods

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

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

data AlgTyConRhs Source #

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]

TupleTyCon 

Fields

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

visibleDataCons :: AlgTyConRhs -> [DataCon] Source #

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 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 Source #

Constructors

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

Instances details
Outputable AlgTyConFlav Source # 
Instance details

Defined in GHC.Core.TyCon

data FamTyConFlav Source #

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

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

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

Instances details
Outputable FamTyConFlav Source # 
Instance details

Defined in GHC.Core.TyCon

data Role Source #

Instances

Instances details
Data Role Source # 
Instance details

Defined in GHC.Core.Coercion.Axiom

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role Source #

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role Source #

toConstr :: Role -> Constr Source #

dataTypeOf :: Role -> DataType Source #

dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c Role) Source #

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

gmapT :: (forall b. Data b => b -> b) -> Role -> Role Source #

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source #

gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source #

gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] Source #

gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u Source #

gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role Source #

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source #

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source #

Binary Role Source # 
Instance details

Defined in GHC.Core.Coercion.Axiom

Outputable Role Source # 
Instance details

Defined in GHC.Core.Coercion.Axiom

Eq Role Source # 
Instance details

Defined in GHC.Core.Coercion.Axiom

Methods

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

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

Ord Role Source # 
Instance details

Defined in GHC.Core.Coercion.Axiom

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 #

data Injectivity Source #

Constructors

NotInjective 
Injective [Bool] 

Instances

Instances details
Binary Injectivity Source # 
Instance details

Defined in GHC.Core.TyCon

Eq Injectivity Source # 
Instance details

Defined in GHC.Core.TyCon

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

Constructors

NoRRI

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

data TyConFlavour Source #

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

Instances

Instances details
Outputable TyConFlavour Source # 
Instance details

Defined in GHC.Core.TyCon

Eq TyConFlavour Source # 
Instance details

Defined in GHC.Core.TyCon

TyConBinder

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

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

mkAlgTyCon Source #

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. 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 Source #

Simpler specialization of mkAlgTyCon for classes

mkFunTyCon :: Name -> [TyConBinder] -> Name -> TyCon Source #

Given the name of the function type constructor and it's kind, create the corresponding TyCon. It is recommended to use funTyCon if you want this functionality

mkPrimTyCon Source #

Arguments

:: Name 
-> [TyConBinder] 
-> Kind

result kind, never levity-polymorphic

-> [Role] 
-> TyCon 

Create an unlifted primitive TyCon, such as Int#.

mkKindTyCon Source #

Arguments

:: Name 
-> [TyConBinder] 
-> Kind

result kind

-> [Role] 
-> Name 
-> TyCon 

Kind constructors

mkLiftedPrimTyCon Source #

Arguments

:: Name 
-> [TyConBinder] 
-> Kind

result kind

-> [Role] 
-> TyCon 

Create a lifted primitive TyCon such as RealWorld

mkTupleTyCon Source #

Arguments

:: Name 
-> [TyConBinder] 
-> Kind

Result kind of the TyCon

-> Arity

Arity of the tuple TyCon

-> DataCon 
-> TupleSort

Whether the tuple is boxed or unboxed

-> AlgTyConFlav 
-> TyCon 

mkSumTyCon Source #

Arguments

:: Name 
-> [TyConBinder] 
-> Kind

Kind of the resulting TyCon

-> Arity

Arity of the sum

-> [TyVar]

TyVars scoped over: see tyConTyVars

-> [DataCon] 
-> AlgTyConFlav 
-> TyCon 

mkSynonymTyCon Source #

Arguments

:: Name 
-> [TyConBinder] 
-> Kind

result kind

-> [Role] 
-> Type 
-> Bool 
-> Bool 
-> TyCon 

Create a type synonym TyCon

mkFamilyTyCon Source #

Arguments

:: Name 
-> [TyConBinder] 
-> Kind

result kind

-> Maybe Name 
-> FamTyConFlav 
-> Maybe Class 
-> Injectivity 
-> TyCon 

Create a type family TyCon

mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConTyCoBinder] -> Kind -> [Role] -> RuntimeRepInfo -> TyCon Source #

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 Source #

Arguments

:: Name 
-> [TyConBinder] 
-> Kind

result kind only

-> [(Name, TcTyVar)]

Scoped type variables; see Note [How TcTyCons work] in GHC.Tc.TyCl

-> Bool

Is this TcTyCon generalised already?

-> TyConFlavour

What sort of TyCon 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 also Note [Kind checking recursive type and class declarations] in GHC.Tc.TyCl.

noTcTyConScopedTyVars :: [(Name, TcTyVar)] Source #

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

Predicates on TyCons

isAlgTyCon :: TyCon -> Bool Source #

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

isVanillaAlgTyCon :: TyCon -> Bool Source #

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

isConstraintKindCon :: TyCon -> Bool Source #

Returns True for the TyCon of the Constraint kind.

isClassTyCon :: TyCon -> Bool Source #

Is this TyCon that for a class instance?

isFamInstTyCon :: TyCon -> Bool Source #

Is this TyCon that for a data family instance?

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.

isUnboxedTupleTyCon :: TyCon -> Bool Source #

Is this the TyCon for an unboxed tuple?

isBoxedTupleTyCon :: TyCon -> Bool Source #

Is this the TyCon for a boxed tuple?

isUnboxedSumTyCon :: TyCon -> Bool Source #

Is this the TyCon for an unboxed sum?

isPromotedTupleTyCon :: TyCon -> Bool Source #

Is this the TyCon for a promoted tuple?

isTypeSynonymTyCon :: TyCon -> Bool Source #

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

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

isKindTyCon :: TyCon -> Bool Source #

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

isDataTyCon :: TyCon -> Bool Source #

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

isEnumerationTyCon :: TyCon -> Bool Source #

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

isNewTyCon :: TyCon -> Bool Source #

Is this TyCon that for a newtype

isAbstractTyCon :: TyCon -> Bool Source #

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

isFamilyTyCon :: TyCon -> Bool Source #

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

isOpenFamilyTyCon :: TyCon -> Bool Source #

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

isTypeFamilyTyCon :: TyCon -> Bool Source #

Is this a synonym TyCon that can have may have further instances appear?

isDataFamilyTyCon :: TyCon -> Bool Source #

Is this a synonym TyCon that can have may have further instances appear?

isOpenTypeFamilyTyCon :: TyCon -> Bool Source #

Is this an open type family TyCon?

isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched) Source #

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

tyConInjectivityInfo :: TyCon -> Injectivity Source #

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

isUnliftedTyCon :: TyCon -> Bool Source #

Is this TyCon unlifted (i.e. cannot contain bottom)? Note that this can only be true for primitive and unboxed-tuple TyCons

isGadtSyntaxTyCon :: TyCon -> Bool Source #

Is this an algebraic TyCon declared with the GADT syntax?

isInjectiveTyCon :: TyCon -> Role -> Bool Source #

isInjectiveTyCon is true of TyCons 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 GHC.Tc.Solver.Canonical

isGenerativeTyCon :: TyCon -> Role -> Bool Source #

isGenerativeTyCon is true of TyCons 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 GHC.Tc.Solver.Canonical

isGenInjAlgRhs :: AlgTyConRhs -> Bool Source #

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

isTyConAssoc :: TyCon -> Bool Source #

Is this TyCon for an associated type?

tyConAssoc_maybe :: TyCon -> Maybe TyCon Source #

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

tyConFlavourAssoc_maybe :: TyConFlavour -> Maybe TyCon Source #

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

isImplicitTyCon :: TyCon -> Bool Source #

Identifies implicit tycons that, in particular, do not go into interface files (because they are implicitly reconstructed when the interface is read).

Note that:

  • Associated families are implicit, as they are 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 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 type-checking?)

isTcLevPoly :: TyCon -> Bool Source #

Could this TyCon ever be levity-polymorphic when fully applied? True is safe. False means we're sure. Does only a quick check based on the TyCon's category. Precondition: The fully-applied TyCon has kind (TYPE blah)

Extracting information out of TyCons

tyConName :: TyCon -> Name Source #

Name of the constructor

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]

tyConKind :: TyCon -> Kind Source #

Kind of this TyCon

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

tyConCType :: TyCon -> Maybe CType Source #

The C type that should be used for this type when using the FFI and CAPI

tyConDataCons :: TyCon -> [DataCon] Source #

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

tyConDataCons_maybe :: TyCon -> Maybe [DataCon] Source #

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 Source #

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

tyConFamilySize :: TyCon -> Int Source #

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

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

tyConRoles :: TyCon -> [Role] Source #

Get the list of roles for the type parameters of a TyCon

tyConClass_maybe :: TyCon -> Maybe Class Source #

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

tyConATs :: TyCon -> [TyCon] Source #

Return the associated types of the TyCon, if any

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

tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched) Source #

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 Source #

Extract type variable naming the result of injective type family

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

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

famTcResVar :: TyCon -> Maybe Name Source #

Name of result type variable, used for pretty-printing with --show-iface and for reifying TyCon in Template Haskell

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

newTyConRhs :: TyCon -> ([TyVar], Type) Source #

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

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

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

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

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.

algTcFields :: TyCon -> FieldLabelEnv Source #

Maps a label to information about the field

tyConBinders :: TyCon -> [TyConBinder] Source #

Full binders

tyConResKind :: TyCon -> Kind Source #

Result kind

tcTyConScopedTyVars :: TyCon -> [(Name, TyVar)] Source #

Scoped tyvars over the tycon's body See Note [Scoped tyvars in a TcTyCon]

tcTyConIsPoly :: TyCon -> Bool Source #

Is this TcTyCon already generalized?

Manipulating TyCons

expandSynTyCon_maybe Source #

Arguments

:: TyCon 
-> [tyco]

Arguments to TyCon

-> Maybe ([(TyVar, tyco)], Type, [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, if any

newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched) Source #

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

Predicated on TyConFlavours

tcFlavourIsOpen :: TyConFlavour -> Bool Source #

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

Runtime type representation

mkPrelTyConRepName :: Name -> TyConRepName Source #

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

data PrimRep Source #

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 
LiftedRep 
UnliftedRep

Unlifted pointer

Int8Rep

Signed, 8-bit value

Int16Rep

Signed, 16-bit value

Int32Rep

Signed, 32-bit value

Int64Rep

Signed, 64 bit value (with 32-bit words only)

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 (with 32-bit words only)

WordRep

Unsigned, word-sized value

AddrRep

A pointer, but not to a Haskell value (use '(Un)liftedRep')

FloatRep 
DoubleRep 
VecRep Int PrimElemRep

A vector

Instances

Instances details
Show PrimRep Source # 
Instance details

Defined in GHC.Core.TyCon

Outputable PrimRep Source # 
Instance details

Defined in GHC.Core.TyCon

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

primRepIsFloat :: PrimRep -> Maybe Bool Source #

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

Recursion breaking

defaultRecTcMaxBound :: Int Source #

The default upper bound (100) for the number of times a RecTcChecker is allowed to encounter each TyCon.

setRecTcMaxBound :: Int -> RecTcChecker -> RecTcChecker Source #

Change the upper bound for the number of times a RecTcChecker is allowed to encounter each TyCon.