Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell2010 |
GHC.Core.TyCon
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 { }
- | 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
- isNoParent :: AlgTyConFlav -> Bool
- data FamTyConFlav
- data Role
- data Injectivity
- = NotInjective
- | Injective [Bool]
- data PromDataConInfo
- = NoPromInfo
- | RuntimeRep ([Type] -> [PrimRep])
- | VecCount Int
- | VecElem PrimElemRep
- | Levity Levity
- data TyConFlavour tc
- type TyConBinder = VarBndr TyVar TyConBndrVis
- data TyConBndrVis
- 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
- 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
- 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
- data PrimElemRep
- data Levity
- primElemRepToPrimRep :: PrimElemRep -> PrimRep
- isVoidRep :: PrimRep -> Bool
- isGcPtrRep :: PrimRep -> Bool
- primRepSizeB :: Platform -> PrimRep -> Int
- primElemRepSizeB :: Platform -> 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
TyCons represent type constructors. Type constructors are introduced by things such as:
1) Data declarations: data Foo = ...
creates the Foo
type constructor of
kind Type
2) Type synonyms: type Foo = ...
creates the Foo
type constructor
3) Newtypes: newtype Foo a = MkFoo ...
creates the Foo
type constructor
of kind Type -> Type
4) Class declarations: class Foo where
creates the Foo
type constructor
of kind Constraint
This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.
If you edit this type, you may need to update the GHC formalism See Note [GHC Formalism] in GHC.Core.Lint
Instances
Data TyCon # | |
Defined in GHC.Core.TyCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCon -> c TyCon gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCon dataTypeOf :: TyCon -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c TyCon) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCon) gmapT :: (forall b. Data b => b -> b) -> TyCon -> TyCon gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r gmapQ :: (forall d. Data d => d -> u) -> TyCon -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCon -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon | |
NamedThing TyCon # | |
Defined in GHC.Core.TyCon | |
Uniquable TyCon # | |
Defined in GHC.Core.TyCon | |
Outputable TyCon # | |
Defined in GHC.Core.TyCon | |
Eq TyCon # | |
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 |
Fields
| |
TupleTyCon | |
SumTyCon | An unboxed sum type. |
Fields
| |
NewTyCon | Information about those |
Fields
|
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 3) A |
Instances
Outputable AlgTyConFlav # | |
Defined in GHC.Core.TyCon Methods ppr :: AlgTyConFlav -> SDoc # |
isNoParent :: AlgTyConFlav -> Bool #
data FamTyConFlav #
Information pertaining to the expansion of a type synonym (type
)
Constructors
DataFamilyTyCon TyConRepName | Represents an open type family without a fixed right hand side. Additional instances can appear at any time. These are introduced by either a top level declaration: data family T a :: Type Or an associated data type declaration, within a class declaration: class C a b where data T b :: Type |
OpenSynFamilyTyCon | An open type synonym family e.g. |
ClosedSynFamilyTyCon (Maybe (CoAxiom Branched)) | A closed type synonym family e.g.
|
AbstractClosedSynFamilyTyCon | A closed type synonym family declared in an hs-boot file with type family F a where .. |
BuiltInSynFamTyCon BuiltInSynFamily | Built-in type family used by the TypeNats solver |
Instances
Outputable FamTyConFlav # | |
Defined in GHC.Core.TyCon Methods ppr :: FamTyConFlav -> SDoc # |
See Note [Roles] in GHC.Core.Coercion
Order of constructors matters: the Ord instance coincides with the *super*typing relation on roles.
Constructors
Nominal | |
Representational | |
Phantom |
Instances
Data Role # | |
Defined in Language.Haskell.Syntax.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role 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 # | |
Outputable Role # | |
Defined in GHC.Core.Coercion.Axiom | |
Eq Role # | |
Ord Role # | |
type Anno (Maybe Role) # | |
type Anno (Maybe Role) # | |
data Injectivity #
Constructors
NotInjective | |
Injective [Bool] |
Instances
Binary Injectivity # | |
Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> Injectivity -> IO () # put :: BinHandle -> Injectivity -> IO (Bin Injectivity) # get :: BinHandle -> IO Injectivity # | |
Eq Injectivity # | |
Defined in GHC.Core.TyCon |
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 |
VecCount Int | A constructor of |
VecElem PrimElemRep | A constructor of |
Levity Levity | A constructor of |
data TyConFlavour tc #
Paints a picture of what a TyCon
represents, in broad strokes.
This is used towards more informative error messages.
Constructors
Instances
Functor TyConFlavour # | |
Defined in GHC.Types.Basic Methods fmap :: (a -> b) -> TyConFlavour a -> TyConFlavour b # (<$) :: a -> TyConFlavour b -> TyConFlavour a # | |
Data tc => Data (TyConFlavour tc) # | |
Defined in GHC.Types.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyConFlavour tc -> c (TyConFlavour tc) gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (TyConFlavour tc) toConstr :: TyConFlavour tc -> Constr dataTypeOf :: TyConFlavour tc -> DataType dataCast1 :: Typeable t => (forall d. Data d => c (t d)) -> Maybe (c (TyConFlavour tc)) dataCast2 :: Typeable t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (TyConFlavour tc)) gmapT :: (forall b. Data b => b -> b) -> TyConFlavour tc -> TyConFlavour tc gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyConFlavour tc -> r gmapQr :: forall r r'. (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyConFlavour tc -> r gmapQ :: (forall d. Data d => d -> u) -> TyConFlavour tc -> [u] gmapQi :: Int -> (forall d. Data d => d -> u) -> TyConFlavour tc -> u gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyConFlavour tc -> m (TyConFlavour tc) gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyConFlavour tc -> m (TyConFlavour tc) gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyConFlavour tc -> m (TyConFlavour tc) | |
NFData tc => NFData (TyConFlavour tc) # | |
Defined in GHC.Types.Basic Methods rnf :: TyConFlavour tc -> () | |
Outputable (TyConFlavour tc) # | |
Defined in GHC.Types.Basic Methods ppr :: TyConFlavour tc -> SDoc # | |
Eq tc => Eq (TyConFlavour tc) # | |
Defined in GHC.Types.Basic Methods (==) :: TyConFlavour tc -> TyConFlavour tc -> Bool # (/=) :: TyConFlavour tc -> TyConFlavour tc -> Bool # |
TyConBinder
type TyConBinder = VarBndr TyVar TyConBndrVis #
data TyConBndrVis #
Constructors
NamedTCB ForAllTyFlag | A named, forall-bound variable (invisible or not) |
AnonTCB | an ordinary, visible type argument |
Instances
Binary TyConBndrVis # | |
Defined in GHC.Core.TyCon Methods put_ :: BinHandle -> TyConBndrVis -> IO () # put :: BinHandle -> TyConBndrVis -> IO (Bin TyConBndrVis) # get :: BinHandle -> IO TyConBndrVis # | |
Outputable TyConBndrVis # | |
Defined in GHC.Core.TyCon Methods ppr :: TyConBndrVis -> SDoc # | |
OutputableBndr tv => Outputable (VarBndr tv TyConBndrVis) # | |
Defined in GHC.Core.TyCon Methods ppr :: VarBndr tv TyConBndrVis -> SDoc # |
mkNamedTyConBinder :: ForAllTyFlag -> TyVar -> TyConBinder #
mkNamedTyConBinders :: ForAllTyFlag -> [TyVar] -> [TyConBinder] #
mkRequiredTyConBinder :: TyCoVarSet -> TyVar -> TyConBinder #
Make a Required TyConBinder. It chooses between NamedTCB and AnonTCB based on whether the tv is mentioned in the dependent set
mkAnonTyConBinder :: TyVar -> TyConBinder #
mkAnonTyConBinders :: [TyVar] -> [TyConBinder] #
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
Arguments
:: Name | |
-> [TyConBinder] | Binders of the |
-> 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 |
-> AlgTyConRhs | Information about data constructors |
-> AlgTyConFlav | What flavour is it? (e.g. vanilla, type family) |
-> Bool | Was the |
-> TyCon |
This is the making of an algebraic TyCon
.
mkClassTyCon :: Name -> [TyConBinder] -> [Role] -> AlgTyConRhs -> Class -> Name -> TyCon #
Simpler specialization of mkAlgTyCon
for classes
Arguments
:: Name | |
-> [TyConBinder] | |
-> Kind | result kind
Must answer |
-> [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.
Arguments
:: Name | |
-> [TyConBinder] | |
-> Kind | Result kind of the |
-> DataCon | |
-> TupleSort | Whether the tuple is boxed or unboxed |
-> AlgTyConFlav | |
-> TyCon |
Arguments
:: Name | |
-> [TyConBinder] | |
-> Kind | Kind of the resulting |
-> [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
Arguments
:: Bool | whether the |
-> 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
).
Arguments
:: Name | |
-> [TyConBinder] | |
-> Kind | result kind |
-> [Role] | |
-> Type | |
-> Bool | |
-> Bool | |
-> Bool | |
-> Bool | |
-> TyCon |
Create a type synonym TyCon
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
Arguments
:: Name | |
-> [TyConBinder] | |
-> Kind | result kind only |
-> [(Name, TcTyVar)] | Scoped type variables; |
-> Bool | Is this TcTyCon generalised already? |
-> TyConFlavour TyCon | What sort of |
-> TyCon |
Makes a tycon suitable for use during type-checking. It stores a variety of details about the definition of the TyCon, but no right-hand side. It lives only during the type-checking of a mutually-recursive group of tycons; it is then zonked to a proper TyCon in zonkTcTyCon. See Note [TcTyCon, MonoTcTyCon, and PolyTcTyCon] in GHC.Tc.TyCl
noTcTyConScopedTyVars :: [(Name, TcTyVar)] #
No scoped type variables (to be used with mkTcTyCon).
Predicates on TyCons
isAlgTyCon :: TyCon -> Bool #
Returns True
if the supplied TyCon
resulted from either a
data
or newtype
declaration
isVanillaAlgTyCon :: TyCon -> Bool #
Returns True
for vanilla AlgTyCons -- that is, those created
with a data
or newtype
declaration.
isClassTyCon :: TyCon -> Bool #
Is this TyCon
that for a class instance?
isFamInstTyCon :: TyCon -> Bool #
Is this TyCon
that for a data family instance?
isPrimTyCon :: TyCon -> Bool #
Does this TyCon
represent something that cannot be defined in Haskell?
isTupleTyCon :: TyCon -> Bool #
Does this TyCon
represent a tuple?
NB: when compiling Data.Tuple
, the tycons won't reply True
to
isTupleTyCon
, because they are built as AlgTyCons
. However they
get spat into the interface file as tuple tycons, so I don't think
it matters.
isUnboxedTupleTyCon :: TyCon -> Bool #
Is this the TyCon
for an unboxed tuple?
isBoxedTupleTyCon :: TyCon -> Bool #
Is this the TyCon
for a boxed tuple?
isUnboxedSumTyCon :: TyCon -> Bool #
Is this the TyCon
for an unboxed sum?
isPromotedTupleTyCon :: TyCon -> Bool #
Is this the TyCon
for a promoted tuple?
isLiftedAlgTyCon :: TyCon -> Bool #
isTypeSynonymTyCon :: TyCon -> Bool #
Is this a TyCon
representing a regular H98 type synonym (type
)?
tyConMustBeSaturated :: TyCon -> Bool #
True iff we can decompose (T a b c) into ((T a b) c) I.e. is it injective and generative w.r.t nominal equality? That is, if (T a b) ~N d e f, is it always the case that (T ~N d), (a ~N e) and (b ~N f)? Specifically NOT true of synonyms (open and otherwise)
It'd be unusual to call tyConMustBeSaturated on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable
isPromotedDataCon :: TyCon -> Bool #
Is this a PromotedDataCon?
isPromotedDataCon_maybe :: TyCon -> Maybe DataCon #
Retrieves the promoted DataCon if this is a PromotedDataCon;
isDataKindsPromotedDataCon :: TyCon -> Bool #
This function identifies PromotedDataCon's from data constructors in `data T = K1 | K2`, promoted by -XDataKinds. These type constructors are printed with a tick mark 'K1 and 'K2, and similarly have a tick mark added to their OccName's.
In contrast, constructors in `type data T = K1 | K2` are printed and represented with their original undecorated names. See Note [Type data declarations] in GHC.Rename.Module
isKindTyCon :: TyCon -> Bool #
Is this tycon really meant for use at the kind level? That is, should it be permitted without -XDataKinds?
isLiftedTypeKindTyConName :: Name -> Bool #
isTauTyCon :: TyCon -> Bool #
isFamFreeTyCon :: TyCon -> Bool #
Is this tycon neither a type family nor a synonym that expands to a type family?
isForgetfulSynTyCon :: TyCon -> Bool #
Is this a forgetful type synonym? If this is a type synonym whose RHS does not mention one (or more) of its bound variables, returns True. Thus, False means that all bound variables appear on the RHS; True may not mean anything, as the test to set this flag is conservative.
isDataTyCon :: TyCon -> Bool #
Returns True
for data types that are definitely represented by
heap-allocated constructors. These are scrutinised by Core-level
case
expressions, and they get info tables allocated for them.
Generally, the function will be true for all data
types and false
for 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 #
returns tyConInjectivityInfo
tc
if Injective
istc
is an
injective tycon (where is
states for which tyConBinders
tc
is
injective), or NotInjective
otherwise.
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.
setTcTyConKind :: TyCon -> Kind -> TyCon #
tcHasFixedRuntimeRep :: TyCon -> Bool #
Does this TyCon
have a syntactically fixed RuntimeRep when fully applied,
as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete?
False is safe. True means we're sure. Does only a quick check, based on the TyCon's category.
See Note [Representation-polymorphic TyCons]
isConcreteTyCon :: TyCon -> Bool #
Is this TyCon
concrete?
More specifically, if tys
are all concrete, is (T tys) concrete?
(for synonyms this requires us to look at the RHS)
Used for representation polymorphism checks.
See Note [Concrete types] in GHC.Tc.Utils.Concrete
Extracting information out of TyCons
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]
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] #
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 #
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 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
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) #
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) #
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) #
unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched) #
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] |
Arguments
:: TyCon | |
-> [tyco] | Arguments to |
-> ExpandSynResult tyco | Returns a |
newTyConCo :: TyCon -> CoAxiom Unbranched #
newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched) #
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 #
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
A PrimRep
is an abstraction of a type. It contains information that
the code generator needs in order to pass arguments, return results,
and store values of this type. See also Note [RuntimeRep and PrimRep] in
GHC.Types.RepType and Note [VoidRep] in GHC.Types.RepType.
Constructors
VoidRep | |
BoxedRep !(Maybe Levity) | Boxed, heap value |
Int8Rep | Signed, 8-bit value |
Int16Rep | Signed, 16-bit value |
Int32Rep | Signed, 32-bit value |
Int64Rep | Signed, 64 bit value |
IntRep | Signed, word-sized value |
Word8Rep | Unsigned, 8 bit value |
Word16Rep | Unsigned, 16 bit value |
Word32Rep | Unsigned, 32 bit value |
Word64Rep | Unsigned, 64 bit value |
WordRep | Unsigned, word-sized value |
AddrRep | A pointer, but not to a Haskell value (use |
FloatRep | |
DoubleRep | |
VecRep Int PrimElemRep | A vector |
Instances
Data PrimRep # | |
Defined in GHC.Core.TyCon Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> PrimRep -> c PrimRep gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c PrimRep 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 # | |
Binary PrimRep # | |
Outputable PrimRep # | |
Defined in GHC.Core.TyCon | |
Eq PrimRep # | |
Ord PrimRep # | |
data PrimElemRep #
Constructors
Int8ElemRep | |
Int16ElemRep | |
Int32ElemRep | |
Int64ElemRep | |
Word8ElemRep | |
Word16ElemRep | |
Word32ElemRep | |
Word64ElemRep | |
FloatElemRep | |
DoubleElemRep |
Instances
Instances
Data Levity # | |
Defined in GHC.Types.Basic Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Levity -> c Levity gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Levity 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 # | |
Binary Levity # | |
Outputable Levity # | |
Defined in GHC.Types.Basic | |
Eq Levity # | |
Ord Levity # | |
isGcPtrRep :: PrimRep -> Bool #
primRepSizeB :: Platform -> PrimRep -> Int #
The size of a PrimRep
in bytes.
This applies also when used in a constructor, where we allow packing the
fields. For instance, in data Foo = Foo Float# Float#
the two fields will
take only 8 bytes, which for 64-bit arch will be equal to 1 word.
See also mkVirtHeapOffsetsWithPadding for details of how data fields are
laid out.
primElemRepSizeB :: Platform -> PrimElemRep -> Int #
primRepIsFloat :: PrimRep -> Maybe Bool #
Return if Rep stands for floating type, returns Nothing for vector types.
primRepIsWord :: PrimRep -> Bool #
primRepIsInt :: PrimRep -> Bool #