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

Safe Haskell | Ignore
Language | GHC2021

GHC.Core.DataCon

Contents

- Main data types
  - Equality specs
  - Field labels
  - Type construction
  - Type deconstruction
  - Predicates on DataCons
  - Promotion related functions
- Orphan instances

Synopsis

- data DataCon
- data DataConRep
  - = NoDataConRep
  - | DCR {
    - dcr_wrap_id :: Id
    - dcr_boxer :: DataConBoxer
    - dcr_arg_tys :: [Scaled Type]
    - dcr_stricts :: [StrictnessMark]
    - dcr_bangs :: [HsImplBang]
    }
- data SrcStrictness
  - = SrcLazy
  - | SrcStrict
  - | NoSrcStrict
- data SrcUnpackedness
  - = SrcUnpack
  - | SrcNoUnpack
  - | NoSrcUnpack
- data HsSrcBang = HsSrcBang SourceText HsBang
- data HsBang = HsBang SrcUnpackedness SrcStrictness
- data HsImplBang
  - = HsLazy
  - | HsStrict Bool
  - | HsUnpack (Maybe Coercion)
- data StrictnessMark
  - = MarkedStrict
  - | NotMarkedStrict
- type ConTag = Int
- type DataConEnv a = UniqFM DataCon a
- data EqSpec
- mkEqSpec :: TyVar -> Type -> EqSpec
- eqSpecTyVar :: EqSpec -> TyVar
- eqSpecType :: EqSpec -> Type
- eqSpecPair :: EqSpec -> (TyVar, Type)
- eqSpecPreds :: [EqSpec] -> ThetaType
- data FieldLabel = FieldLabel {
  - flHasDuplicateRecordFields :: DuplicateRecordFields
  - flHasFieldSelector :: FieldSelectors
  - flSelector :: Name
  }
- flLabel :: FieldLabel -> FieldLabelString
- data FieldLabelString
- mkHsSrcBang :: SourceText -> SrcUnpackedness -> SrcStrictness -> HsSrcBang
- mkDataCon :: Name -> Bool -> TyConRepName -> [HsSrcBang] -> [FieldLabel] -> [TyVar] -> [TyCoVar] -> ConcreteTyVars -> [InvisTVBinder] -> [EqSpec] -> KnotTied ThetaType -> [KnotTied (Scaled Type)] -> KnotTied Type -> PromDataConInfo -> KnotTied TyCon -> ConTag -> ThetaType -> Id -> DataConRep -> DataCon
- fIRST_TAG :: ConTag
- dataConRepType :: DataCon -> Type
- dataConInstSig :: DataCon -> [Type] -> ([TyCoVar], ThetaType, [Type])
- dataConFullSig :: DataCon -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, [Scaled Type], Type)
- dataConName :: DataCon -> Name
- dataConIdentity :: DataCon -> ByteString
- dataConTag :: DataCon -> ConTag
- dataConTagZ :: DataCon -> ConTagZ
- dataConTyCon :: DataCon -> TyCon
- dataConOrigTyCon :: DataCon -> TyCon
- dataConWrapperType :: DataCon -> Type
- dataConNonlinearType :: DataCon -> Type
- dataConDisplayType :: Bool -> DataCon -> Type
- dataConUnivTyVars :: DataCon -> [TyVar]
- dataConExTyCoVars :: DataCon -> [TyCoVar]
- dataConUnivAndExTyCoVars :: DataCon -> [TyCoVar]
- dataConConcreteTyVars :: DataCon -> ConcreteTyVars
- dataConUserTyVars :: DataCon -> [TyVar]
- dataConUserTyVarBinders :: DataCon -> [InvisTVBinder]
- dataConTheta :: DataCon -> ThetaType
- dataConStupidTheta :: DataCon -> ThetaType
- dataConOtherTheta :: DataCon -> ThetaType
- dataConInstArgTys :: DataCon -> [Type] -> [Scaled Type]
- dataConOrigArgTys :: DataCon -> [Scaled Type]
- dataConOrigResTy :: DataCon -> Type
- dataConInstOrigArgTys :: DataCon -> [Type] -> [Scaled Type]
- dataConRepArgTys :: DataCon -> [Scaled Type]
- dataConResRepTyArgs :: DataCon -> [Type]
- dataConInstUnivs :: DataCon -> [Type] -> [Type]
- dataConFieldLabels :: DataCon -> [FieldLabel]
- dataConFieldType :: DataCon -> FieldLabelString -> Type
- dataConFieldType_maybe :: DataCon -> FieldLabelString -> Maybe (FieldLabel, Type)
- dataConSrcBangs :: DataCon -> [HsSrcBang]
- dataConSourceArity :: DataCon -> Arity
- dataConRepArity :: DataCon -> Arity
- dataConIsInfix :: DataCon -> Bool
- dataConWorkId :: DataCon -> Id
- dataConWrapId :: DataCon -> Id
- dataConWrapId_maybe :: DataCon -> Maybe Id
- dataConImplicitTyThings :: DataCon -> [TyThing]
- dataConRepStrictness :: DataCon -> [StrictnessMark]
- dataConImplBangs :: DataCon -> [HsImplBang]
- dataConBoxer :: DataCon -> Maybe DataConBoxer
- splitDataProductType_maybe :: Type -> Maybe (TyCon, [Type], DataCon, [Scaled Type])
- isNullarySrcDataCon :: DataCon -> Bool
- isNullaryRepDataCon :: DataCon -> Bool
- isTupleDataCon :: DataCon -> Bool
- isBoxedTupleDataCon :: DataCon -> Bool
- isUnboxedTupleDataCon :: DataCon -> Bool
- isUnboxedSumDataCon :: DataCon -> Bool
- isCovertGadtDataCon :: DataCon -> Bool
- isVanillaDataCon :: DataCon -> Bool
- isNewDataCon :: DataCon -> Bool
- isTypeDataCon :: DataCon -> Bool
- classDataCon :: Class -> DataCon
- dataConCannotMatch :: [Type] -> DataCon -> Bool
- dataConUserTyVarsNeedWrapper :: DataCon -> Bool
- checkDataConTyVars :: DataCon -> Bool
- isBanged :: HsImplBang -> Bool
- isMarkedStrict :: StrictnessMark -> Bool
- cbvFromStrictMark :: StrictnessMark -> CbvMark
- eqHsBang :: HsImplBang -> HsImplBang -> Bool
- isSrcStrict :: SrcStrictness -> Bool
- isSrcUnpacked :: SrcUnpackedness -> Bool
- specialPromotedDc :: DataCon -> Bool
- promoteDataCon :: DataCon -> TyCon

# Main data types

data DataCon Source #

A data constructor

#### Instances

Instances details

Data DataCon Source # |

Instance details

Defined in GHC.Core.DataCon

Methods

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

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

toConstr :: DataCon -> Constr Source #

dataTypeOf :: DataCon -> DataType Source #

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

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

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

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

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

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

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

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

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

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

NamedThing DataCon Source # |
Instance details Defined in GHC.Core.DataCon Methods getOccName :: DataCon -> OccName Source # getName :: DataCon -> Name Source #
Uniquable DataCon Source # |
Instance details Defined in GHC.Core.DataCon Methods getUnique :: DataCon -> Unique Source #
Outputable DataCon Source # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: DataCon -> SDoc Source #
OutputableBndr DataCon Source # |
Instance details Defined in GHC.Core.DataCon Methods pprBndr :: BindingSite -> DataCon -> SDoc Source # pprPrefixOcc :: DataCon -> SDoc Source # pprInfixOcc :: DataCon -> SDoc Source # bndrIsJoin_maybe :: DataCon -> JoinPointHood Source #
Eq DataCon Source # |
Instance details Defined in GHC.Core.DataCon Methods (==) :: DataCon -> DataCon -> Bool Source # (/=) :: DataCon -> DataCon -> Bool Source #

data DataConRep Source #

Data Constructor Representation See Note [Data constructor workers and wrappers]

Constructors

NoDataConRep |
DCR |

Fields

- dcr_wrap_id :: Id
- dcr_boxer :: DataConBoxer
- dcr_arg_tys :: [Scaled Type]
- dcr_stricts :: [StrictnessMark]
- dcr_bangs :: [HsImplBang]

data SrcStrictness Source #

Source Strictness

What strictness annotation the user wrote

Constructors

SrcLazy | Lazy, ie `~`
SrcStrict | Strict, ie `!`
NoSrcStrict | no strictness annotation

#### Instances

Instances details

Data SrcStrictness Source # |

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

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

toConstr :: SrcStrictness -> Constr Source #

dataTypeOf :: SrcStrictness -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Binary SrcStrictness Source # |
Instance details Defined in GHC.Core.DataCon Methods put_ :: WriteBinHandle -> SrcStrictness -> IO () Source # put :: WriteBinHandle -> SrcStrictness -> IO (Bin SrcStrictness) Source # get :: ReadBinHandle -> IO SrcStrictness Source #
Outputable SrcStrictness Source # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: SrcStrictness -> SDoc Source #
Eq SrcStrictness Source # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: SrcStrictness -> SrcStrictness -> Bool Source # (/=) :: SrcStrictness -> SrcStrictness -> Bool Source #

data SrcUnpackedness Source #

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack | {-# UNPACK #-} specified
SrcNoUnpack | {-# NOUNPACK #-} specified
NoSrcUnpack | no unpack pragma

#### Instances

Instances details

Data SrcUnpackedness Source # |

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

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

toConstr :: SrcUnpackedness -> Constr Source #

dataTypeOf :: SrcUnpackedness -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Binary SrcUnpackedness Source # |
Instance details Defined in GHC.Core.DataCon Methods put_ :: WriteBinHandle -> SrcUnpackedness -> IO () Source # put :: WriteBinHandle -> SrcUnpackedness -> IO (Bin SrcUnpackedness) Source # get :: ReadBinHandle -> IO SrcUnpackedness Source #
Outputable SrcUnpackedness Source # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: SrcUnpackedness -> SDoc Source #
Eq SrcUnpackedness Source # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: SrcUnpackedness -> SrcUnpackedness -> Bool Source # (/=) :: SrcUnpackedness -> SrcUnpackedness -> Bool Source #

data HsSrcBang Source #

Haskell Source Bang

Bangs on data constructor arguments as written by the user, including the source code for exact-printing.

In the AST, the SourceText is deconstructed and hidden inside `XBangTy` extension point.

Constructors

HsSrcBang SourceText HsBang |

data HsBang Source #

Haskell Bang

Bangs on data constructor arguments written by the user.

`(HsBang SrcUnpack SrcLazy)` and `(HsBang SrcUnpack NoSrcStrict)` (without StrictData) makes no sense, we emit a warning (in checkValidDataCon) and treat it like `(HsBang NoSrcUnpack SrcLazy)`

`HsSrcBang` is a wrapper around this, associating it with a `SourceText` as written by the user. In the AST, the `SourceText` is hidden inside the extension point `XBangTy`.

Constructors

HsBang SrcUnpackedness SrcStrictness |

#### Instances

Instances details

Data HsBang Source # |

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

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

toConstr :: HsBang -> Constr Source #

dataTypeOf :: HsBang -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable HsBang Source # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: HsBang -> SDoc Source #

data HsImplBang Source #

Haskell Implementation Bang

Bangs of data constructor arguments as generated by the compiler after consulting HsSrcBang, flags, etc.

Constructors

HsLazy | Lazy field, or one with an unlifted type
HsStrict Bool | Strict but not unpacked field True = we could have unpacked, but opted not to because of -O0. See Note [Detecting useless UNPACK pragmas]
HsUnpack (Maybe Coercion) | Strict and unpacked field co :: arg-ty ~ product-ty HsBang

#### Instances

Instances details

Data HsImplBang Source # |

Instance details

Defined in GHC.Core.DataCon

Methods

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

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

toConstr :: HsImplBang -> Constr Source #

dataTypeOf :: HsImplBang -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Outputable HsImplBang Source # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: HsImplBang -> SDoc Source #

data StrictnessMark Source #

Constructors

MarkedStrict |
NotMarkedStrict |

#### Instances

Instances details

Binary StrictnessMark Source # |
Instance details Defined in GHC.Core.DataCon Methods put_ :: WriteBinHandle -> StrictnessMark -> IO () Source # put :: WriteBinHandle -> StrictnessMark -> IO (Bin StrictnessMark) Source # get :: ReadBinHandle -> IO StrictnessMark Source #
Outputable StrictnessMark Source # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: StrictnessMark -> SDoc Source #
Eq StrictnessMark Source # |
Instance details Defined in GHC.Core.DataCon Methods (==) :: StrictnessMark -> StrictnessMark -> Bool Source # (/=) :: StrictnessMark -> StrictnessMark -> Bool Source #

type ConTag = Int Source #

A *one-index* constructor tag

Type of the tags associated with each constructor possibility or superclass selector

type DataConEnv a = UniqFM DataCon a Source #

## Equality specs

data EqSpec Source #

An `EqSpec` is a tyvar/type pair representing an equality made in rejigging a GADT constructor

#### Instances

Instances details

Outputable EqSpec Source # |
Instance details Defined in GHC.Core.DataCon Methods ppr :: EqSpec -> SDoc Source #

mkEqSpec :: TyVar -> Type -> EqSpec Source #

Make a non-dependent `EqSpec`

eqSpecTyVar :: EqSpec -> TyVar Source #

eqSpecType :: EqSpec -> Type Source #

eqSpecPair :: EqSpec -> (TyVar, Type) Source #

eqSpecPreds :: [EqSpec] -> ThetaType Source #

## Field labels

data FieldLabel Source #

Fields in an algebraic record type; see Note [FieldLabel].

Constructors

FieldLabel |

Fields

- flHasDuplicateRecordFields :: DuplicateRecordFields

  Was `DuplicateRecordFields` on in the defining module for this datatype?

- flHasFieldSelector :: FieldSelectors

  Was `FieldSelectors` enabled in the defining module for this datatype? See Note [NoFieldSelectors] in GHC.Rename.Env

- flSelector :: Name

  The `Name` of the selector function, which uniquely identifies the field label.

#### Instances

Instances details

NFData FieldLabel Source # |
Instance details Defined in GHC.Types.Name Methods rnf :: FieldLabel -> () Source #
Data FieldLabel Source # |

Instance details

Defined in GHC.Types.FieldLabel

Methods

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

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

toConstr :: FieldLabel -> Constr Source #

dataTypeOf :: FieldLabel -> DataType Source #

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

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

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

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

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

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

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

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

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

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

HasOccName FieldLabel Source # |
Instance details Defined in GHC.Types.FieldLabel Methods occName :: FieldLabel -> OccName Source #
Binary Name => Binary FieldLabel Source # | We need the `Binary Name` constraint here even though there is an instance defined in GHC.Types.Name, because the we have a SOURCE import, so the instance is not in scope. And the instance cannot be added to Name.hs-boot because GHC.Utils.Binary itself depends on GHC.Types.Name.
Instance details Defined in GHC.Types.FieldLabel Methods put_ :: WriteBinHandle -> FieldLabel -> IO () Source # put :: WriteBinHandle -> FieldLabel -> IO (Bin FieldLabel) Source # get :: ReadBinHandle -> IO FieldLabel Source #
Outputable FieldLabel Source # |
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: FieldLabel -> SDoc Source #
Eq FieldLabel Source # |
Instance details Defined in GHC.Types.FieldLabel Methods (==) :: FieldLabel -> FieldLabel -> Bool Source # (/=) :: FieldLabel -> FieldLabel -> Bool Source #

flLabel :: FieldLabel -> FieldLabelString Source #

User-visible label of a field.

data FieldLabelString Source #

Field labels are just represented as strings; they are not necessarily unique (even within a module)

#### Instances

Instances details

NFData FieldLabelString Source # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods rnf :: FieldLabelString -> () Source #
Data FieldLabelString Source # |

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

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

toConstr :: FieldLabelString -> Constr Source #

dataTypeOf :: FieldLabelString -> DataType Source #

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

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

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

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

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

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

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

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

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

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

Uniquable FieldLabelString Source # |
Instance details Defined in GHC.Types.FieldLabel Methods getUnique :: FieldLabelString -> Unique Source #
Outputable FieldLabelString Source # |
Instance details Defined in GHC.Types.FieldLabel Methods ppr :: FieldLabelString -> SDoc Source #
Eq FieldLabelString Source # |
Instance details Defined in Language.Haskell.Syntax.Basic Methods (==) :: FieldLabelString -> FieldLabelString -> Bool Source # (/=) :: FieldLabelString -> FieldLabelString -> Bool Source #
type Anno FieldLabelString Source # |
Instance details Defined in GHC.Hs.Expr type Anno FieldLabelString = SrcSpanAnnN

## Type construction

mkHsSrcBang :: SourceText -> SrcUnpackedness -> SrcStrictness -> HsSrcBang Source #

Make a `HsSrcBang` from all parts

mkDataCon Source #

Arguments

:: Name |
-> Bool | Is the constructor declared infix?
-> TyConRepName | TyConRepName for the promoted TyCon
-> [HsSrcBang] | Strictness/unpack annotations, from user
-> [FieldLabel] | Field labels for the constructor, if it is a record, otherwise empty
-> [TyVar] | Universals.
-> [TyCoVar] | Existentials.
-> ConcreteTyVars | TyVars which must be instantiated with concrete types
-> [InvisTVBinder] | User-written `TyVarBinder`s. These must be Inferred/Specified. See `Note [TyVarBinders in DataCons]`
-> [EqSpec] | GADT equalities
-> KnotTied ThetaType | Theta-type occurring before the arguments proper
-> [KnotTied (Scaled Type)] | Original argument types
-> KnotTied Type | Original result type
-> PromDataConInfo | See comments on `PromDataConInfo`
-> KnotTied TyCon | Representation type constructor
-> ConTag | Constructor tag
-> ThetaType | The "stupid theta", context of the data declaration e.g. `data Eq a => T a ...`
-> Id | Worker Id
-> DataConRep | Representation
-> DataCon |

Build a new data constructor

fIRST_TAG :: ConTag Source #

Tags are allocated from here for real constructors or for superclass selectors

## Type deconstruction

dataConRepType :: DataCon -> Type Source #

The representation type of the data constructor, i.e. the sort type that will represent values of this type at runtime

dataConInstSig :: DataCon -> [Type] -> ([TyCoVar], ThetaType, [Type]) Source #

Instantiate the universal tyvars of a data con, returning ( instantiated existentials , instantiated constraints including dependent GADT equalities which are *also* listed in the instantiated existentials , instantiated args)

dataConFullSig :: DataCon -> ([TyVar], [TyCoVar], [EqSpec], ThetaType, [Scaled Type], Type) Source #

The "full signature" of the `DataCon` returns, in order:

1) The result of `dataConUnivTyVars`

2) The result of `dataConExTyCoVars`

3) The non-dependent GADT equalities. Dependent GADT equalities are implied by coercion variables in return value (2).

4) The other constraints of the data constructor type, excluding GADT equalities

5) The original argument types to the `DataCon` (i.e. before any change of the representation of the type) with linearity annotations

6) The original result type of the `DataCon`

dataConName :: DataCon -> Name Source #

The `Name` of the `DataCon`, giving it a unique, rooted identification

dataConIdentity :: DataCon -> ByteString Source #

The string `package:module.name` identifying a constructor, which is attached to its info table and used by the GHCi debugger and the heap profiler

dataConTag :: DataCon -> ConTag Source #

The tag used for ordering `DataCon`s

dataConTagZ :: DataCon -> ConTagZ Source #

dataConTyCon :: DataCon -> TyCon Source #

The type constructor that we are building via this data constructor

dataConOrigTyCon :: DataCon -> TyCon Source #

The original type constructor used in the definition of this data constructor. In case of a data family instance, that will be the family type constructor.

dataConWrapperType :: DataCon -> Type Source #

The user-declared type of the data constructor in the nice-to-read form:

    T :: forall a b. a -> b -> T [a]

rather than:

    T :: forall a c. forall b. (c~[a]) => a -> b -> T c

The type variables are quantified in the order that the user wrote them. See `Note [DataCon user type variable binders]`.

NB: If the constructor is part of a data instance, the result type mentions the family tycon, not the internal one.

dataConNonlinearType :: DataCon -> Type Source #

dataConDisplayType :: Bool -> DataCon -> Type Source #

dataConUnivTyVars :: DataCon -> [TyVar] Source #

The universally-quantified type variables of the constructor

dataConExTyCoVars :: DataCon -> [TyCoVar] Source #

The existentially-quantified type/coercion variables of the constructor including dependent (kind-) GADT equalities

dataConUnivAndExTyCoVars :: DataCon -> [TyCoVar] Source #

Both the universal and existential type/coercion variables of the constructor

dataConConcreteTyVars :: DataCon -> ConcreteTyVars Source #

Which type variables of this data constructor that must be instantiated to concrete types? For example: the RuntimeRep variables of unboxed tuples and unboxed sums.

See Note [Representation-polymorphism checking built-ins] in GHC.Tc.Utils.Concrete

dataConUserTyVars :: DataCon -> [TyVar] Source #

The type variables of the constructor, in the order the user wrote them

dataConUserTyVarBinders :: DataCon -> [InvisTVBinder] Source #

`InvisTVBinder`s for the type variables of the constructor, in the order the user wrote them

dataConTheta :: DataCon -> ThetaType Source #

The *full* constraints on the constructor type, including dependent GADT equalities.

dataConStupidTheta :: DataCon -> ThetaType Source #

The "stupid theta" of the `DataCon`, such as `data Eq a` in:

    data Eq a => T a = ...

See `Note [The stupid context]`.

dataConOtherTheta :: DataCon -> ThetaType Source #

Returns constraints in the wrapper type, other than those in the dataConEqSpec

dataConInstArgTys Source #

Arguments

:: DataCon | A datacon with no existentials or equality constraints However, it can have a dcTheta (notably it can be a class dictionary, with superclasses)
-> [Type] | Instantiated at these types
-> [Scaled Type] |

Finds the instantiated types of the arguments required to construct a `DataCon` representation NB: these INCLUDE any dictionary args but EXCLUDE the data-declaration context, which is discarded It's all post-flattening etc; this is a representation type

dataConOrigArgTys :: DataCon -> [Scaled Type] Source #

Returns the argument types of the wrapper, excluding all dictionary arguments and without substituting for any type variables

dataConOrigResTy :: DataCon -> Type Source #

dataConInstOrigArgTys :: DataCon -> [Type] -> [Scaled Type] Source #

Returns just the instantiated value argument types of a `DataCon`, (excluding dictionary args)

dataConRepArgTys :: DataCon -> [Scaled Type] Source #

Returns the arg types of the worker, including *all* non-dependent evidence, after any flattening has been done and without substituting for any type variables

dataConResRepTyArgs :: DataCon -> [Type] Source #

Were the type variables of the data con written in a different order than the regular order (universal tyvars followed by existential tyvars)?

This is not a cheap test, so we minimize its use in GHC as much as possible. Currently, its only call site in the GHC codebase is in `mkDataConRep` in MkId, and so `dataConUserTyVarsNeedWrapper` is only called at most once during a data constructor's lifetime.

dataConInstUnivs :: DataCon -> [Type] -> [Type] Source #

Given a data constructor `dc` with n universally quantified type variables `a_{1}`, `a_{2}`, ..., `a_{n}`, and given a list of argument types `dc_args` of length m where m <= n, then:

    dataConInstUnivs dc dc_args

Will return:

    [dc_arg_{1}, dc_arg_{2}, ..., dc_arg_{m}, a_{m+1}, ..., a_{n}]

That is, return the list of universal type variables with `a_{1}`, `a_{2}`, ..., `a_{m}` instantiated with `dc_arg_{1}`, `dc_arg_{2}`, ..., `dc_arg_{m}`. It is possible for `m` to be less than `n`, in which case the remaining `n - m` elements will simply be universal type variables (with their kinds possibly instantiated).

Examples:

- Given the data constructor `D :: forall a b. Foo a b` and `dc_args` `[Int, Bool]`, then `dataConInstUnivs D dc_args` will return `[Int, Bool]`.
- Given the data constructor `D :: forall a b. Foo a b` and `dc_args` `[Int]`, then @`dataConInstUnivs D dc_args` will return `[Int, b]`.
- Given the data constructor `E :: forall k (a :: k). Bar k a` and `dc_args` `[Type]`, then @`dataConInstUnivs D dc_args` will return `[Type, (a :: Type)]`.

This is primarily used in `GHC.Tc.Deriv.*` in service of instantiating data constructors' field types. See `Note [Instantiating field types in stock deriving]` for a notable example of this.

dataConFieldLabels :: DataCon -> [FieldLabel] Source #

The labels for the fields of this particular `DataCon`

dataConFieldType :: DataCon -> FieldLabelString -> Type Source #

Extract the type for any given labelled field of the `DataCon`

dataConFieldType_maybe :: DataCon -> FieldLabelString -> Maybe (FieldLabel, Type) Source #

Extract the label and type for any given labelled field of the `DataCon`, or return `Nothing` if the field does not belong to it

dataConSrcBangs :: DataCon -> [HsSrcBang] Source #

Strictness/unpack annotations, from user; or, for imported DataCons, from the interface file The list is in one-to-one correspondence with the arity of the `DataCon`

dataConSourceArity :: DataCon -> Arity Source #

Source-level arity of the data constructor

dataConRepArity :: DataCon -> Arity Source #

Gives the number of value arguments (including zero-width coercions) stored by the given `DataCon`'s worker in its Core representation. This may differ from the number of arguments that appear in the source code; see also Note [DataCon arities]

dataConIsInfix :: DataCon -> Bool Source #

Should the `DataCon` be presented infix?

dataConWorkId :: DataCon -> Id Source #

Get the Id of the `DataCon` worker: a function that is the "actual" constructor and has no top level binding in the program. The type may be different from the obvious one written in the source program. Panics if there is no such `Id` for this `DataCon`

dataConWrapId :: DataCon -> Id Source #

Returns an Id which looks like the Haskell-source constructor by using the wrapper if it exists (see `dataConWrapId_maybe`) and failing over to the worker (see `dataConWorkId`)

dataConWrapId_maybe :: DataCon -> Maybe Id Source #

Get the Id of the `DataCon` wrapper: a function that wraps the "actual" constructor so it has the type visible in the source program: c.f. `dataConWorkId`. Returns Nothing if there is no wrapper, which occurs for an algebraic data constructor and also for a newtype (whose constructor is inlined compulsorily)

dataConImplicitTyThings :: DataCon -> [TyThing] Source #

Find all the `Id`s implicitly brought into scope by the data constructor. Currently, the union of the `dataConWorkId` and the `dataConWrapId`

dataConRepStrictness :: DataCon -> [StrictnessMark] Source #

Give the demands on the arguments of a Core constructor application (Con dc args)

dataConImplBangs :: DataCon -> [HsImplBang] Source #

dataConBoxer :: DataCon -> Maybe DataConBoxer Source #

splitDataProductType_maybe Source #

Arguments

:: Type | A product type, perhaps
-> Maybe (TyCon, [Type], DataCon, [Scaled Type]) |

Extract the type constructor, type argument, data constructor and it's representation argument types from a type if it is a product type.

Precisely, we return `Just` for any data type that is all of:

- Concrete (i.e. constructors visible)
- Single-constructor
- ... which has no existentials

Whether the type is a `data` type or a `newtype`.

## Predicates on DataCons

isNullarySrcDataCon :: DataCon -> Bool Source #

Return whether there are any argument types for this `DataCon`s original source type See Note [DataCon arities]

isNullaryRepDataCon :: DataCon -> Bool Source #

Return whether this `DataCon`'s worker, in its Core representation, takes any value arguments.

In particular, remember that we include coercion arguments in the arity of the Core representation of the `DataCon` -- both lifted and unlifted coercions, despite the latter having zero-width runtime representation.

See also Note [DataCon arities].

isTupleDataCon :: DataCon -> Bool Source #

isBoxedTupleDataCon :: DataCon -> Bool Source #

isUnboxedTupleDataCon :: DataCon -> Bool Source #

isUnboxedSumDataCon :: DataCon -> Bool Source #

isCovertGadtDataCon :: DataCon -> Bool Source #

isVanillaDataCon :: DataCon -> Bool Source #

Vanilla `DataCon`s are those that are nice boring Haskell 98 constructors

isNewDataCon :: DataCon -> Bool Source #

Is this the `DataCon` of a newtype?

isTypeDataCon :: DataCon -> Bool Source #

Is this data constructor in a "type data" declaration? See Note [Type data declarations] in GHC.Rename.Module.

classDataCon :: Class -> DataCon Source #

dataConCannotMatch :: [Type] -> DataCon -> Bool Source #

dataConUserTyVarsNeedWrapper :: DataCon -> Bool Source #

checkDataConTyVars :: DataCon -> Bool Source #

isBanged :: HsImplBang -> Bool Source #

isMarkedStrict :: StrictnessMark -> Bool Source #

cbvFromStrictMark :: StrictnessMark -> CbvMark Source #

eqHsBang :: HsImplBang -> HsImplBang -> Bool Source #

Compare strictness annotations

isSrcStrict :: SrcStrictness -> Bool Source #

isSrcUnpacked :: SrcUnpackedness -> Bool Source #

specialPromotedDc :: DataCon -> Bool Source #

Should this DataCon be allowed in a type even without -XDataKinds? Currently, only Lifted & Unlifted

## Promotion related functions

promoteDataCon :: DataCon -> TyCon Source #

# Orphan instances

Binary SrcStrictness Source # |
Instance details Methods put_ :: WriteBinHandle -> SrcStrictness -> IO () Source # put :: WriteBinHandle -> SrcStrictness -> IO (Bin SrcStrictness) Source # get :: ReadBinHandle -> IO SrcStrictness Source #
Binary SrcUnpackedness Source # |
Instance details Methods put_ :: WriteBinHandle -> SrcUnpackedness -> IO () Source # put :: WriteBinHandle -> SrcUnpackedness -> IO (Bin SrcUnpackedness) Source # get :: ReadBinHandle -> IO SrcUnpackedness Source #
Outputable HsBang Source # |
Instance details Methods ppr :: HsBang -> SDoc Source #
Outputable SrcStrictness Source # |
Instance details Methods ppr :: SrcStrictness -> SDoc Source #
Outputable SrcUnpackedness Source # |
Instance details Methods ppr :: SrcUnpackedness -> SDoc Source #