ghc-lib-parser-9.10.1.20250103: The GHC API, decoupled from GHC versions

Safe Haskell | Ignore
Language | GHC2021

GHC.Core.TyCon

Contents

- Main TyCon data types
- TyConBinder
  - Field labels
  - Constructing TyCons
  - Predicates on TyCons
  - Extracting information out of TyCons
  - Manipulating TyCons
  - Predicated on TyConFlavours
- Runtime type representation
- Primitive representations of Types

Synopsis

- data TyCon
- data AlgTyConRhs
  - = AbstractTyCon
  - | DataTyCon {
    - data_cons :: [DataCon]
    - data_cons_size :: Int
    - is_enum :: Bool
    - is_type_data :: Bool
    - data_fixed_lev :: Bool
    }
  - | TupleTyCon {
    - data_con :: DataCon
    - tup_sort :: TupleSort
    }
  - | SumTyCon {
    - data_cons :: [DataCon]
    - data_cons_size :: Int
    }
  - | NewTyCon {
    - data_con :: DataCon
    - nt_rhs :: Type
    - nt_etad_rhs :: ([TyVar], Type)
    - nt_co :: CoAxiom Unbranched
    - nt_fixed_rep :: Bool
    }
- visibleDataCons :: AlgTyConRhs -> [DataCon]
- data AlgTyConFlav
  - = VanillaAlgTyCon TyConRepName
  - | UnboxedSumTyCon
  - | ClassTyCon Class TyConRepName
  - | DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type]
- isNoParent :: AlgTyConFlav -> Bool
- data FamTyConFlav
  - = DataFamilyTyCon TyConRepName
  - | OpenSynFamilyTyCon
  - | ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))
  - | AbstractClosedSynFamilyTyCon
  - | BuiltInSynFamTyCon BuiltInSynFamily
- data Role
  - = Nominal
  - | Representational
  - | Phantom
- data Injectivity
  - = NotInjective
  - | Injective [Bool]
- data PromDataConInfo
  - = NoPromInfo
  - | RuntimeRep ([Type] -> [PrimRep])
  - | VecCount Int
  - | VecElem PrimElemRep
  - | Levity Levity
- data TyConFlavour tc
  - = ClassFlavour
  - | TupleFlavour Boxity
  - | SumFlavour
  - | DataTypeFlavour
  - | NewtypeFlavour
  - | AbstractTypeFlavour
  - | OpenFamilyFlavour TypeOrData (Maybe tc)
  - | ClosedTypeFamilyFlavour
  - | TypeSynonymFlavour
  - | BuiltInTypeFlavour
  - | PromotedDataConFlavour
- type TyConBinder = VarBndr TyVar TyConBndrVis
- data TyConBndrVis
  - = NamedTCB ForAllTyFlag
  - | AnonTCB
- mkNamedTyConBinder :: ForAllTyFlag -> TyVar -> TyConBinder
- mkNamedTyConBinders :: ForAllTyFlag -> [TyVar] -> [TyConBinder]
- mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder
- mkAnonTyConBinder :: TyVar -> TyConBinder
- mkAnonTyConBinders :: [TyVar] -> [TyConBinder]
- tyConBinderForAllTyFlag :: TyConBinder -> ForAllTyFlag
- tyConBndrVisForAllTyFlag :: TyConBndrVis -> ForAllTyFlag
- isNamedTyConBinder :: TyConBinder -> Bool
- isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool
- isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool
- isVisibleTcbVis :: TyConBndrVis -> Bool
- isInvisSpecTcbVis :: TyConBndrVis -> Bool
- tyConFieldLabels :: TyCon -> [FieldLabel]
- lookupTyConFieldLabel :: FieldLabelString -> TyCon -> Maybe FieldLabel
- mkAlgTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Maybe CType -> [PredType] -> AlgTyConRhs -> AlgTyConFlav -> Bool -> TyCon
- mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon
- mkPrimTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> TyCon
- mkTupleTyCon :: Name -> [TyConBinder] -> Kind -> DataCon -> TupleSort -> AlgTyConFlav -> TyCon
- mkSumTyCon :: Name -> [TyConBinder] -> Kind -> [DataCon] -> AlgTyConFlav -> TyCon
- mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
- mkLevPolyDataTyConRhs :: Bool -> Bool -> [DataCon] -> AlgTyConRhs
- mkSynonymTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Type -> Bool -> Bool -> Bool -> Bool -> TyCon
- mkFamilyTyCon :: Name -> [TyConBinder] -> Kind -> Maybe Name -> FamTyConFlav -> Maybe Class -> Injectivity -> TyCon
- mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConBinder] -> Kind -> [Role] -> PromDataConInfo -> TyCon
- mkTcTyCon :: Name -> [TyConBinder] -> Kind -> [(Name, TcTyVar)] -> Bool -> TyConFlavour TyCon -> TyCon
- noTcTyConScopedTyVars :: [(Name, TcTyVar)]
- isAlgTyCon :: TyCon -> Bool
- isVanillaAlgTyCon :: TyCon -> Bool
- isClassTyCon :: TyCon -> Bool
- isFamInstTyCon :: TyCon -> Bool
- isPrimTyCon :: TyCon -> Bool
- isTupleTyCon :: TyCon -> Bool
- isUnboxedTupleTyCon :: TyCon -> Bool
- isBoxedTupleTyCon :: TyCon -> Bool
- isUnboxedSumTyCon :: TyCon -> Bool
- isPromotedTupleTyCon :: TyCon -> Bool
- isLiftedAlgTyCon :: TyCon -> Bool
- isTypeSynonymTyCon :: TyCon -> Bool
- tyConMustBeSaturated :: TyCon -> Bool
- isPromotedDataCon :: TyCon -> Bool
- isPromotedDataCon_maybe :: TyCon -> Maybe DataCon
- isDataKindsPromotedDataCon :: TyCon -> Bool
- isKindTyCon :: TyCon -> Bool
- isKindName :: Name -> Bool
- isLiftedTypeKindTyConName :: Name -> Bool
- isTauTyCon :: TyCon -> Bool
- isFamFreeTyCon :: TyCon -> Bool
- isForgetfulSynTyCon :: TyCon -> Bool
- isDataTyCon :: TyCon -> Bool
- isTypeDataTyCon :: TyCon -> Bool
- isEnumerationTyCon :: TyCon -> Bool
- isNewTyCon :: TyCon -> Bool
- isAbstractTyCon :: TyCon -> Bool
- isFamilyTyCon :: TyCon -> Bool
- isOpenFamilyTyCon :: TyCon -> Bool
- isTypeFamilyTyCon :: TyCon -> Bool
- isDataFamilyTyCon :: TyCon -> Bool
- isOpenTypeFamilyTyCon :: TyCon -> Bool
- isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)
- tyConInjectivityInfo :: TyCon -> Injectivity
- isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily
- isGadtSyntaxTyCon :: TyCon -> Bool
- isInjectiveTyCon :: TyCon -> Role -> Bool
- isGenerativeTyCon :: TyCon -> Role -> Bool
- isGenInjAlgRhs :: AlgTyConRhs -> Bool
- isTyConAssoc :: TyCon -> Bool
- tyConAssoc_maybe :: TyCon -> Maybe TyCon
- tyConFlavourAssoc_maybe :: TyConFlavour tc -> Maybe tc
- isImplicitTyCon :: TyCon -> Bool
- isTyConWithSrcDataCons :: TyCon -> Bool
- isTcTyCon :: TyCon -> Bool
- setTcTyConKind :: TyCon -> Kind -> TyCon
- tcHasFixedRuntimeRep :: TyCon -> Bool
- isConcreteTyCon :: TyCon -> Bool
- isValidDTT2TyCon :: TyCon -> Bool
- tyConName :: TyCon -> Name
- tyConSkolem :: TyCon -> Bool
- tyConKind :: TyCon -> Kind
- tyConUnique :: TyCon -> Unique
- tyConTyVars :: TyCon -> [TyVar]
- tyConVisibleTyVars :: TyCon -> [TyVar]
- tyConCType_maybe :: TyCon -> Maybe CType
- tyConDataCons :: TyCon -> [DataCon]
- tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
- tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
- tyConSingleDataCon :: TyCon -> DataCon
- tyConAlgDataCons_maybe :: TyCon -> Maybe [DataCon]
- tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon
- tyConFamilySize :: TyCon -> Int
- tyConStupidTheta :: TyCon -> [PredType]
- tyConArity :: TyCon -> Arity
- tyConNullaryTy :: TyCon -> Type
- mkTyConTy :: TyCon -> Type
- tyConRoles :: TyCon -> [Role]
- tyConFlavour :: TyCon -> TyConFlavour TyCon
- tyConTuple_maybe :: TyCon -> Maybe TupleSort
- tyConClass_maybe :: TyCon -> Maybe Class
- tyConATs :: TyCon -> [TyCon]
- tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
- tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)
- tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
- tyConFamilyResVar_maybe :: TyCon -> Maybe Name
- synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
- synTyConRhs_maybe :: TyCon -> Maybe Type
- famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav
- algTyConRhs :: TyCon -> AlgTyConRhs
- newTyConRhs :: TyCon -> ([TyVar], Type)
- newTyConEtadArity :: TyCon -> Int
- newTyConEtadRhs :: TyCon -> ([TyVar], Type)
- unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
- unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
- newTyConDataCon_maybe :: TyCon -> Maybe DataCon
- algTcFields :: TyConDetails -> FieldLabelEnv
- tyConPromDataConInfo :: TyCon -> PromDataConInfo
- tyConBinders :: TyCon -> [TyConBinder]
- tyConResKind :: TyCon -> Kind
- tyConInvisTVBinders :: [TyConBinder] -> [InvisTVBinder]
- tcTyConScopedTyVars :: TyCon -> [(Name, TcTyVar)]
- isMonoTcTyCon :: TyCon -> Bool
- tyConHasClosedResKind :: TyCon -> Bool
- mkTyConTagMap :: TyCon -> NameEnv ConTag
- data ExpandSynResult tyco
  - = NoExpansion
  - | ExpandsSyn [(TyVar, tyco)] Type [tyco]
- expandSynTyCon_maybe :: TyCon -> [tyco] -> ExpandSynResult tyco
- newTyConCo :: TyCon -> CoAxiom Unbranched
- newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
- pprPromotionQuote :: TyCon -> SDoc
- mkTyConKind :: [TyConBinder] -> Kind -> Kind
- tcFlavourIsOpen :: TyConFlavour tc -> Bool
- type TyConRepName = Name
- tyConRepName_maybe :: TyCon -> Maybe TyConRepName
- mkPrelTyConRepName :: Name -> TyConRepName
- tyConRepModOcc :: Module -> OccName -> (Module, OccName)
- data PrimRep
  - = BoxedRep !(Maybe Levity)
  - | Int8Rep
  - | Int16Rep
  - | Int32Rep
  - | Int64Rep
  - | IntRep
  - | Word8Rep
  - | Word16Rep
  - | Word32Rep
  - | Word64Rep
  - | WordRep
  - | AddrRep
  - | FloatRep
  - | DoubleRep
  - | VecRep Int PrimElemRep
- data PrimElemRep
  - = Int8ElemRep
  - | Int16ElemRep
  - | Int32ElemRep
  - | Int64ElemRep
  - | Word8ElemRep
  - | Word16ElemRep
  - | Word32ElemRep
  - | Word64ElemRep
  - | FloatElemRep
  - | DoubleElemRep
- data Levity
  - = Lifted
  - | Unlifted
- data PrimOrVoidRep
  - = VoidRep
  - | NVRep PrimRep
- primElemRepToPrimRep :: PrimElemRep -> PrimRep
- isGcPtrRep :: PrimRep -> Bool
- primRepSizeB :: Platform -> PrimRep -> Int
- primRepSizeW64_B :: PrimRep -> Int
- primElemRepSizeB :: Platform -> PrimElemRep -> Int
- primElemRepSizeW64_B :: PrimElemRep -> Int
- primRepIsFloat :: PrimRep -> Maybe Bool
- primRepsCompatible :: Platform -> [PrimRep] -> [PrimRep] -> Bool
- primRepCompatible :: Platform -> PrimRep -> PrimRep -> Bool
- primRepIsWord :: PrimRep -> Bool
- primRepIsInt :: PrimRep -> Bool

# Main TyCon data types

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

Instances details

Data TyCon # |

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 #

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 # |
Instance details Defined in GHC.Core.TyCon Methods getOccName :: TyCon -> OccName # getName :: TyCon -> Name #
Uniquable TyCon # |
Instance details Defined in GHC.Core.TyCon Methods getUnique :: TyCon -> Unique #
Outputable TyCon # |
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyCon -> SDoc #
Eq TyCon # |
Instance details Defined in GHC.Core.TyCon Methods (==) :: TyCon -> TyCon -> Bool # (/=) :: TyCon -> TyCon -> Bool #

data AlgTyConRhs #

Represents right-hand-sides of `TyCon`s 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 `TyCon`s 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 `TyCon`s 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 `newtype`s do not exist at runtime so need a different representation type).

  The free `TyVar`s 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 `TyVar`s 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 `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 #

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

Instances details

Outputable AlgTyConFlav # |
Instance details 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

Instances details

Outputable FamTyConFlav # |
Instance details 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

Instances details

Data Role # |

Instance details

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 # |
Instance details Defined in GHC.Core.Coercion.Axiom Methods put_ :: BinHandle -> Role -> IO () # put :: BinHandle -> Role -> IO (Bin Role) # get :: BinHandle -> IO Role #
Outputable Role # |
Instance details Defined in GHC.Core.Coercion.Axiom Methods ppr :: Role -> SDoc #
Eq Role # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Ord Role # |
Instance details 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) # |
Instance details Defined in GHC.Hs.Decls type Anno (Maybe Role) = EpAnnCO
type Anno (Maybe Role) # |
Instance details Defined in GHC.Hs.Decls type Anno (Maybe Role) = EpAnnCO

data Injectivity #

Constructors

NotInjective |
Injective [Bool] |

#### Instances

Instances details

Binary Injectivity # |
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> Injectivity -> IO () # put :: BinHandle -> Injectivity -> IO (Bin Injectivity) # get :: BinHandle -> IO Injectivity #
Eq Injectivity # |
Instance details 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

Instances details

Functor TyConFlavour # |
Instance details Defined in GHC.Types.Basic Methods fmap :: (a -> b) -> TyConFlavour a -> TyConFlavour b # (<$) :: a -> TyConFlavour b -> TyConFlavour a #
NFData tc => NFData (TyConFlavour tc) # |
Instance details Defined in GHC.Types.Basic Methods rnf :: TyConFlavour tc -> () #
Data tc => Data (TyConFlavour tc) # |

Instance details

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

Outputable (TyConFlavour tc) # |
Instance details Defined in GHC.Types.Basic Methods ppr :: TyConFlavour tc -> SDoc #
Eq tc => Eq (TyConFlavour tc) # |
Instance details 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

Instances details

Binary TyConBndrVis # |
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> TyConBndrVis -> IO () # put :: BinHandle -> TyConBndrVis -> IO (Bin TyConBndrVis) # get :: BinHandle -> IO TyConBndrVis #
Outputable TyConBndrVis # |
Instance details Defined in GHC.Core.TyCon Methods ppr :: TyConBndrVis -> SDoc #
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis) # |
Instance details 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 `DataKinds`?

isKindName :: Name -> Bool #

This is `Name` really meant for use at the kind level? That is, should it be permitted wihout `DataKinds`?

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 `newtype`s, unboxed tuples, unboxed sums and type family `TyCon`s. But it is not guaranteed to return `True` in all cases that it could.

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

isTypeDataTyCon :: TyCon -> Bool #

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 `TyCon`s for which this property holds (where r is the role passed in): If (T a1 b1 c1) ~r (T a2 b2 c2), then (a1 ~r1 a2), (b1 ~r2 b2), and (c1 ~r3 c2) (where r1, r2, and r3, are the roles given by tyConRolesX tc r) See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.Equality

isGenerativeTyCon :: TyCon -> Role -> Bool #

`isGenerativeTyCon` is true of `TyCon`s for which this property holds (where r is the role passed in): If (T tys ~r t), then (t's head ~r T). See also Note [Decomposing TyConApp equalities] in GHC.Tc.Solver.Equality

NB: at Nominal role, isGenerativeTyCon is simple: isGenerativeTyCon tc Nominal = not (isTypeFamilyTyCon tc || isSynonymTyCon tc)

isGenInjAlgRhs :: AlgTyConRhs -> Bool #

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

isValidDTT2TyCon :: TyCon -> Bool #

Returns `True` if a boxed type headed by the given `TyCon` satisfies condition DTT2 of Note [DataToTag overview] in GHC.Tc.Instance.Class

## Extracting information out of TyCons

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 `DataCon`s 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 `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)

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 `TyVar`s 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 `newtype`s 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 non-void type. (Use `PrimRepOrVoidRep` if you want void types too.) It contains information that the code generator needs in order to pass arguments, return results, and store values of this type. See also Note [RuntimeRep and PrimRep] in GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.

Constructors

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

Instances details

Data PrimRep # |

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) -> 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 # |
Instance details Defined in GHC.Core.TyCon Methods showsPrec :: Int -> PrimRep -> ShowS # show :: PrimRep -> String # showList :: [PrimRep] -> ShowS #
Binary PrimRep # |
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> PrimRep -> IO () # put :: BinHandle -> PrimRep -> IO (Bin PrimRep) # get :: BinHandle -> IO PrimRep #
Outputable PrimRep # |
Instance details Defined in GHC.Core.TyCon Methods ppr :: PrimRep -> SDoc #
Eq PrimRep # |
Instance details Defined in GHC.Core.TyCon Methods (==) :: PrimRep -> PrimRep -> Bool # (/=) :: PrimRep -> PrimRep -> Bool #
Ord PrimRep # |
Instance details 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

Instances details

Data PrimElemRep # |

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

Instance details

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 # |
Instance details Defined in GHC.Core.TyCon Methods showsPrec :: Int -> PrimElemRep -> ShowS # show :: PrimElemRep -> String # showList :: [PrimElemRep] -> ShowS #
Binary PrimElemRep # |
Instance details Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> PrimElemRep -> IO () # put :: BinHandle -> PrimElemRep -> IO (Bin PrimElemRep) # get :: BinHandle -> IO PrimElemRep #
Outputable PrimElemRep # |
Instance details Defined in GHC.Core.TyCon Methods ppr :: PrimElemRep -> SDoc #
Eq PrimElemRep # |
Instance details Defined in GHC.Core.TyCon Methods (==) :: PrimElemRep -> PrimElemRep -> Bool # (/=) :: PrimElemRep -> PrimElemRep -> Bool #
Ord PrimElemRep # |
Instance details 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

Instances details

Data Levity # |

Instance details

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 # |
Instance details Defined in GHC.Types.Basic Methods showsPrec :: Int -> Levity -> ShowS # show :: Levity -> String # showList :: [Levity] -> ShowS #
Binary Levity # |
Instance details Defined in GHC.Types.Basic Methods put_ :: BinHandle -> Levity -> IO () # put :: BinHandle -> Levity -> IO (Bin Levity) # get :: BinHandle -> IO Levity #
Outputable Levity # |
Instance details Defined in GHC.Types.Basic Methods ppr :: Levity -> SDoc #
Eq Levity # |
Instance details Defined in GHC.Types.Basic Methods (==) :: Levity -> Levity -> Bool # (/=) :: Levity -> Levity -> Bool #
Ord Levity # |
Instance details 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 #

data PrimOrVoidRep #

Constructors

VoidRep |
NVRep PrimRep |

primElemRepToPrimRep :: PrimElemRep -> PrimRep #

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.

primRepSizeW64_B :: PrimRep -> Int #

Like primRepSizeB but assumes pointers/words are 8 words wide.

This can be useful to compute the size of a rep as if we were compiling for a 64bit platform.

primElemRepSizeB :: Platform -> PrimElemRep -> Int #

primElemRepSizeW64_B :: PrimElemRep -> Int #

Like primElemRepSizeB but assumes pointers/words are 8 words wide.

This can be useful to compute the size of a rep as if we were compiling for a 64bit platform.

primRepIsFloat :: PrimRep -> Maybe Bool #

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 #