TyCon

ghc-8.10.6: The GHC API

Safe Haskell | None
Language | Haskell2010

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

Synopsis

- data TyCon
- data AlgTyConRhs
  - = AbstractTyCon
  - | DataTyCon {
    - data_cons :: [DataCon]
    - data_cons_size :: Int
    - is_enum :: 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_lev_poly :: Bool
    }
- visibleDataCons :: AlgTyConRhs -> [DataCon]
- data AlgTyConFlav
  - = VanillaAlgTyCon TyConRepName
  - | UnboxedAlgTyCon (Maybe TyConRepName)
  - | 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 RuntimeRepInfo
  - = NoRRI
  - | RuntimeRep ([Type] -> [PrimRep])
  - | VecCount Int
  - | VecElem PrimElemRep
- data TyConFlavour
  - = ClassFlavour
  - | TupleFlavour Boxity
  - | SumFlavour
  - | DataTypeFlavour
  - | NewtypeFlavour
  - | AbstractTypeFlavour
  - | DataFamilyFlavour (Maybe TyCon)
  - | OpenTypeFamilyFlavour (Maybe TyCon)
  - | ClosedTypeFamilyFlavour
  - | TypeSynonymFlavour
  - | BuiltInTypeFlavour
  - | PromotedDataConFlavour
- type TyConBinder = VarBndr TyVar TyConBndrVis
- data TyConBndrVis
  - = NamedTCB ArgFlag
  - | AnonTCB AnonArgFlag
- type TyConTyCoBinder = VarBndr TyCoVar TyConBndrVis
- mkNamedTyConBinder :: ArgFlag -> TyVar -> TyConBinder
- mkNamedTyConBinders :: ArgFlag -> [TyVar] -> [TyConBinder]
- mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder
- mkAnonTyConBinder :: AnonArgFlag -> TyVar -> TyConBinder
- mkAnonTyConBinders :: AnonArgFlag -> [TyVar] -> [TyConBinder]
- tyConBinderArgFlag :: TyConBinder -> ArgFlag
- tyConBndrVisArgFlag :: TyConBndrVis -> ArgFlag
- isNamedTyConBinder :: TyConBinder -> Bool
- isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool
- isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool
- tyConFieldLabels :: TyCon -> [FieldLabel]
- lookupTyConFieldLabel :: FieldLabelString -> TyCon -> Maybe FieldLabel
- mkAlgTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Maybe CType -> [PredType] -> AlgTyConRhs -> AlgTyConFlav -> Bool -> TyCon
- mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon
- mkFunTyCon :: Name -> [TyConBinder] -> Name -> TyCon
- mkPrimTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> TyCon
- mkKindTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Name -> TyCon
- mkLiftedPrimTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> TyCon
- mkTupleTyCon :: Name -> [TyConBinder] -> Kind -> Arity -> DataCon -> TupleSort -> AlgTyConFlav -> TyCon
- mkSumTyCon :: Name -> [TyConBinder] -> Kind -> Arity -> [TyVar] -> [DataCon] -> AlgTyConFlav -> TyCon
- mkDataTyConRhs :: [DataCon] -> AlgTyConRhs
- mkSynonymTyCon :: Name -> [TyConBinder] -> Kind -> [Role] -> Type -> Bool -> Bool -> TyCon
- mkFamilyTyCon :: Name -> [TyConBinder] -> Kind -> Maybe Name -> FamTyConFlav -> Maybe Class -> Injectivity -> TyCon
- mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> [TyConTyCoBinder] -> Kind -> [Role] -> RuntimeRepInfo -> TyCon
- mkTcTyCon :: Name -> [TyConBinder] -> Kind -> [(Name, TcTyVar)] -> Bool -> TyConFlavour -> TyCon
- noTcTyConScopedTyVars :: [(Name, TcTyVar)]
- isAlgTyCon :: TyCon -> Bool
- isVanillaAlgTyCon :: TyCon -> Bool
- isClassTyCon :: TyCon -> Bool
- isFamInstTyCon :: TyCon -> Bool
- isFunTyCon :: TyCon -> Bool
- isPrimTyCon :: TyCon -> Bool
- isTupleTyCon :: TyCon -> Bool
- isUnboxedTupleTyCon :: TyCon -> Bool
- isBoxedTupleTyCon :: TyCon -> Bool
- isUnboxedSumTyCon :: TyCon -> Bool
- isPromotedTupleTyCon :: TyCon -> Bool
- isTypeSynonymTyCon :: TyCon -> Bool
- mustBeSaturated :: TyCon -> Bool
- isPromotedDataCon :: TyCon -> Bool
- isPromotedDataCon_maybe :: TyCon -> Maybe DataCon
- isKindTyCon :: TyCon -> Bool
- isLiftedTypeKindTyConName :: Name -> Bool
- isTauTyCon :: TyCon -> Bool
- isFamFreeTyCon :: TyCon -> Bool
- isDataTyCon :: TyCon -> Bool
- isProductTyCon :: TyCon -> Bool
- isDataProductTyCon_maybe :: TyCon -> Maybe DataCon
- isDataSumTyCon_maybe :: TyCon -> Maybe [DataCon]
- isEnumerationTyCon :: TyCon -> Bool
- isNewTyCon :: TyCon -> Bool
- isAbstractTyCon :: TyCon -> Bool
- isFamilyTyCon :: TyCon -> Bool
- isOpenFamilyTyCon :: TyCon -> Bool
- isTypeFamilyTyCon :: TyCon -> Bool
- isDataFamilyTyCon :: TyCon -> Bool
- isOpenTypeFamilyTyCon :: TyCon -> Bool
- isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)
- tyConInjectivityInfo :: TyCon -> Injectivity
- isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily
- isUnliftedTyCon :: TyCon -> Bool
- isGadtSyntaxTyCon :: TyCon -> Bool
- isInjectiveTyCon :: TyCon -> Role -> Bool
- isGenerativeTyCon :: TyCon -> Role -> Bool
- isGenInjAlgRhs :: AlgTyConRhs -> Bool
- isTyConAssoc :: TyCon -> Bool
- tyConAssoc_maybe :: TyCon -> Maybe TyCon
- tyConFlavourAssoc_maybe :: TyConFlavour -> Maybe TyCon
- isImplicitTyCon :: TyCon -> Bool
- isTyConWithSrcDataCons :: TyCon -> Bool
- isTcTyCon :: TyCon -> Bool
- setTcTyConKind :: TyCon -> Kind -> TyCon
- isTcLevPoly :: TyCon -> Bool
- tyConName :: TyCon -> Name
- tyConSkolem :: TyCon -> Bool
- tyConKind :: TyCon -> Kind
- tyConUnique :: TyCon -> Unique
- tyConTyVars :: TyCon -> [TyVar]
- tyConVisibleTyVars :: TyCon -> [TyVar]
- tyConCType :: TyCon -> Maybe CType
- tyConCType_maybe :: TyCon -> Maybe CType
- tyConDataCons :: TyCon -> [DataCon]
- tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
- tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
- tyConSingleDataCon :: TyCon -> DataCon
- tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon
- tyConFamilySize :: TyCon -> Int
- tyConStupidTheta :: TyCon -> [PredType]
- tyConArity :: TyCon -> Arity
- tyConRoles :: TyCon -> [Role]
- tyConFlavour :: TyCon -> TyConFlavour
- tyConTuple_maybe :: TyCon -> Maybe TupleSort
- tyConClass_maybe :: TyCon -> Maybe Class
- tyConATs :: TyCon -> [TyCon]
- tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
- tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)
- tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
- tyConFamilyResVar_maybe :: TyCon -> Maybe Name
- synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
- synTyConRhs_maybe :: TyCon -> Maybe Type
- famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav
- famTcResVar :: TyCon -> Maybe Name
- algTyConRhs :: TyCon -> AlgTyConRhs
- newTyConRhs :: TyCon -> ([TyVar], Type)
- newTyConEtadArity :: TyCon -> Int
- newTyConEtadRhs :: TyCon -> ([TyVar], Type)
- unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
- unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
- newTyConDataCon_maybe :: TyCon -> Maybe DataCon
- algTcFields :: TyCon -> FieldLabelEnv
- tyConRuntimeRepInfo :: TyCon -> RuntimeRepInfo
- tyConBinders :: TyCon -> [TyConBinder]
- tyConResKind :: TyCon -> Kind
- tyConTyVarBinders :: [TyConBinder] -> [TyVarBinder]
- tcTyConScopedTyVars :: TyCon -> [(Name, TyVar)]
- tcTyConIsPoly :: TyCon -> Bool
- mkTyConTagMap :: TyCon -> NameEnv ConTag
- expandSynTyCon_maybe :: TyCon -> [tyco] -> Maybe ([(TyVar, tyco)], Type, [tyco])
- newTyConCo :: TyCon -> CoAxiom Unbranched
- newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
- pprPromotionQuote :: TyCon -> SDoc
- mkTyConKind :: [TyConBinder] -> Kind -> Kind
- tcFlavourIsOpen :: TyConFlavour -> Bool
- type TyConRepName = Name
- tyConRepName_maybe :: TyCon -> Maybe TyConRepName
- mkPrelTyConRepName :: Name -> TyConRepName
- tyConRepModOcc :: Module -> OccName -> (Module, OccName)
- data PrimRep
  - = VoidRep
  - | LiftedRep
  - | UnliftedRep
  - | 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
- isVoidRep :: PrimRep -> Bool
- isGcPtrRep :: PrimRep -> Bool
- primRepSizeB :: DynFlags -> PrimRep -> Int
- primElemRepSizeB :: PrimElemRep -> Int
- primRepIsFloat :: PrimRep -> Maybe Bool
- primRepsCompatible :: DynFlags -> [PrimRep] -> [PrimRep] -> Bool
- primRepCompatible :: DynFlags -> PrimRep -> PrimRep -> Bool
- data RecTcChecker
- initRecTc :: RecTcChecker
- defaultRecTcMaxBound :: Int
- setRecTcMaxBound :: Int -> RecTcChecker -> RecTcChecker
- checkRecTc :: RecTcChecker -> TyCon -> Maybe RecTcChecker

# 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

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

data AlgTyConRhs Source #

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]
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_lev_poly :: Bool

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 `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 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 TyCoRep
DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type] | Type constructors representing an *instance* of a *data* family. Parameters: 1) The type family in question 2) Instance types; free variables are the `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 TyCon Methods ppr :: AlgTyConFlav -> SDoc Source # pprPrec :: Rational -> AlgTyConFlav -> SDoc Source #

isNoParent :: AlgTyConFlav -> Bool Source #

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 # |
Instance details Defined in TyCon Methods ppr :: FamTyConFlav -> SDoc Source # pprPrec :: Rational -> FamTyConFlav -> SDoc Source #

data Role Source #

Constructors

Nominal |
Representational |
Phantom |

#### Instances

Instances details

Eq Role # |
Instance details Defined in CoAxiom Methods (==) :: Role -> Role -> Bool # (/=) :: Role -> Role -> Bool #
Data Role # |
Instance details Defined in CoAxiom 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 #
Ord Role # |
Instance details Defined in CoAxiom 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 #
Outputable Role # |
Instance details Defined in CoAxiom Methods ppr :: Role -> SDoc Source # pprPrec :: Rational -> Role -> SDoc Source #
Binary Role # |
Instance details Defined in CoAxiom Methods put_ :: BinHandle -> Role -> IO () Source # put :: BinHandle -> Role -> IO (Bin Role) Source # get :: BinHandle -> IO Role Source #

data Injectivity Source #

Constructors

NotInjective |
Injective [Bool] |

#### Instances

Instances details

Eq Injectivity # |
Instance details Defined in TyCon Methods (==) :: Injectivity -> Injectivity -> Bool # (/=) :: Injectivity -> Injectivity -> Bool #
Binary Injectivity # |
Instance details Defined in TyCon Methods put_ :: BinHandle -> Injectivity -> IO () Source # put :: BinHandle -> Injectivity -> IO (Bin Injectivity) Source # get :: BinHandle -> IO Injectivity Source #

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

Constructors

ClassFlavour |
TupleFlavour Boxity |
SumFlavour |
DataTypeFlavour |
NewtypeFlavour |
AbstractTypeFlavour |
DataFamilyFlavour (Maybe TyCon) |
OpenTypeFamilyFlavour (Maybe TyCon) |
ClosedTypeFamilyFlavour |
TypeSynonymFlavour |
BuiltInTypeFlavour | e.g., the `(->)` `TyCon`.
PromotedDataConFlavour |

#### Instances

Instances details

Eq TyConFlavour # |
Instance details Defined in TyCon Methods (==) :: TyConFlavour -> TyConFlavour -> Bool # (/=) :: TyConFlavour -> TyConFlavour -> Bool #
Outputable TyConFlavour # |
Instance details Defined in TyCon Methods ppr :: TyConFlavour -> SDoc Source # pprPrec :: Rational -> TyConFlavour -> SDoc Source #

# TyConBinder

type TyConBinder = VarBndr TyVar TyConBndrVis Source #

data TyConBndrVis Source #

Constructors

NamedTCB ArgFlag |
AnonTCB AnonArgFlag |

#### Instances

Instances details

Outputable TyConBndrVis # |
Instance details Defined in TyCon Methods ppr :: TyConBndrVis -> SDoc Source # pprPrec :: Rational -> TyConBndrVis -> SDoc Source #
Binary TyConBndrVis # |
Instance details Defined in TyCon Methods put_ :: BinHandle -> TyConBndrVis -> IO () Source # put :: BinHandle -> TyConBndrVis -> IO (Bin TyConBndrVis) Source # get :: BinHandle -> IO TyConBndrVis Source #
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis) # |
Instance details Defined in TyCon Methods ppr :: VarBndr tv TyConBndrVis -> SDoc Source # pprPrec :: Rational -> VarBndr tv TyConBndrVis -> SDoc Source #

type TyConTyCoBinder = VarBndr TyCoVar TyConBndrVis Source #

mkNamedTyConBinder :: ArgFlag -> TyVar -> TyConBinder Source #

mkNamedTyConBinders :: ArgFlag -> [TyVar] -> [TyConBinder] Source #

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

mkAnonTyConBinder :: AnonArgFlag -> TyVar -> TyConBinder Source #

mkAnonTyConBinders :: AnonArgFlag -> [TyVar] -> [TyConBinder] Source #

tyConBinderArgFlag :: TyConBinder -> ArgFlag Source #

tyConBndrVisArgFlag :: TyConBndrVis -> ArgFlag Source #

isNamedTyConBinder :: TyConBinder -> Bool Source #

isVisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool Source #

isInvisibleTyConBinder :: VarBndr tv TyConBndrVis -> Bool Source #

## 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] | `TyVar`s scoped over: see `tyConTyVars`
-> [DataCon] |
-> AlgTyConFlav |
-> TyCon |

mkDataTyConRhs :: [DataCon] -> AlgTyConRhs Source #

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

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.

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?

isFunTyCon :: TyCon -> Bool Source #

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?

isLiftedTypeKindTyConName :: Name -> Bool Source #

isTauTyCon :: TyCon -> Bool Source #

isFamFreeTyCon :: TyCon -> Bool Source #

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

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

isProductTyCon :: TyCon -> Bool Source #

isDataProductTyCon_maybe :: TyCon -> Maybe DataCon Source #

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

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.

isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily Source #

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 `TyCon`s

isGadtSyntaxTyCon :: TyCon -> Bool Source #

Is this an algebraic `TyCon` declared with the GADT syntax?

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

`isInjectiveTyCon` is true of `TyCon`s for which this property holds (where X is the role passed in): If (T a1 b1 c1) ~X (T a2 b2 c2), then (a1 ~X1 a2), (b1 ~X2 b2), and (c1 ~X3 c2) (where X1, X2, and X3, are the roles given by tyConRolesX tc X) See also Note [Decomposing equality] in TcCanonical

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

`isGenerativeTyCon` is true of `TyCon`s for which this property holds (where X is the role passed in): If (T tys ~X t), then (t's head ~X T). See also Note [Decomposing equality] in TcCanonical

isGenInjAlgRhs :: AlgTyConRhs -> Bool 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?)

setTcTyConKind :: TyCon -> Kind -> TyCon Source #

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

tyConVisibleTyVars :: TyCon -> [TyVar] Source #

tyConCType :: TyCon -> Maybe CType Source #

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

tyConCType_maybe :: TyCon -> Maybe CType Source #

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

tyConSingleDataCon :: TyCon -> DataCon Source #

tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon Source #

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

tyConArity :: TyCon -> Arity Source #

Arity

tyConRoles :: TyCon -> [Role] Source #

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

tyConFlavour :: TyCon -> TyConFlavour Source #

tyConTuple_maybe :: TyCon -> Maybe TupleSort Source #

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`

tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched) Source #

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 `TyVar`s 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 `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) Source #

newTyConDataCon_maybe :: TyCon -> Maybe DataCon Source #

algTcFields :: TyCon -> FieldLabelEnv Source #

Maps a label to information about the field

tyConRuntimeRepInfo :: TyCon -> RuntimeRepInfo Source #

Extract any `RuntimeRepInfo` from this TyCon

tyConBinders :: TyCon -> [TyConBinder] Source #

Full binders

tyConResKind :: TyCon -> Kind Source #

Result kind

tyConTyVarBinders :: [TyConBinder] -> [TyVarBinder] Source #

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?

mkTyConTagMap :: TyCon -> NameEnv ConTag Source #

## 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 :: TyCon -> CoAxiom Unbranched Source #

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

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

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

## Predicated on TyConFlavours

tcFlavourIsOpen :: TyConFlavour -> Bool Source #

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

# Runtime type representation

type TyConRepName = Name Source #

tyConRepName_maybe :: TyCon -> Maybe TyConRepName Source #

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 `TcTypeable` in TcTypeable.

# 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 RepType and Note [VoidRep] in 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

Eq PrimRep # |
Instance details Defined in TyCon Methods (==) :: PrimRep -> PrimRep -> Bool # (/=) :: PrimRep -> PrimRep -> Bool #
Show PrimRep # |
Instance details Defined in TyCon Methods showsPrec :: Int -> PrimRep -> ShowS Source # show :: PrimRep -> String Source # showList :: [PrimRep] -> ShowS Source #
Outputable PrimRep # |
Instance details Defined in TyCon Methods ppr :: PrimRep -> SDoc Source # pprPrec :: Rational -> PrimRep -> SDoc Source #
Binary PrimRep # |
Instance details Defined in TyCon Methods put_ :: BinHandle -> PrimRep -> IO () Source # put :: BinHandle -> PrimRep -> IO (Bin PrimRep) Source # get :: BinHandle -> IO PrimRep Source #

data PrimElemRep Source #

Constructors

Int8ElemRep |
Int16ElemRep |
Int32ElemRep |
Int64ElemRep |
Word8ElemRep |
Word16ElemRep |
Word32ElemRep |
Word64ElemRep |
FloatElemRep |
DoubleElemRep |

#### Instances

Instances details

Eq PrimElemRep # |
Instance details Defined in TyCon Methods (==) :: PrimElemRep -> PrimElemRep -> Bool # (/=) :: PrimElemRep -> PrimElemRep -> Bool #
Show PrimElemRep # |
Instance details Defined in TyCon Methods showsPrec :: Int -> PrimElemRep -> ShowS Source # show :: PrimElemRep -> String Source # showList :: [PrimElemRep] -> ShowS Source #
Outputable PrimElemRep # |
Instance details Defined in TyCon Methods ppr :: PrimElemRep -> SDoc Source # pprPrec :: Rational -> PrimElemRep -> SDoc Source #
Binary PrimElemRep # |
Instance details Defined in TyCon Methods put_ :: BinHandle -> PrimElemRep -> IO () Source # put :: BinHandle -> PrimElemRep -> IO (Bin PrimElemRep) Source # get :: BinHandle -> IO PrimElemRep Source #

isVoidRep :: PrimRep -> Bool Source #

isGcPtrRep :: PrimRep -> Bool Source #

primRepSizeB :: DynFlags -> 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 layed out.

primElemRepSizeB :: PrimElemRep -> Int Source #

primRepIsFloat :: PrimRep -> Maybe Bool Source #

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

primRepsCompatible :: DynFlags -> [PrimRep] -> [PrimRep] -> Bool Source #

primRepCompatible :: DynFlags -> PrimRep -> PrimRep -> Bool Source #

# Recursion breaking

data RecTcChecker Source #

initRecTc :: RecTcChecker Source #

Initialise a `RecTcChecker` with `defaultRecTcMaxBound`.

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

checkRecTc :: RecTcChecker -> TyCon -> Maybe RecTcChecker Source #