DataCon

Main data types

data DataCon

A data constructor

• AnnKeywordId : AnnOpen, AnnClose,AnnComma

Instances

Eq DataCon

Methods

(==) :: DataCon -> DataCon -> Bool

(/=) :: DataCon -> DataCon -> Bool

Data DataCon

Methods

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

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

toConstr :: DataCon -> Constr

dataTypeOf :: DataCon -> DataType

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

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

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

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

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

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

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

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

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

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

OutputableBndr DataCon

Methods

pprBndr :: BindingSite -> DataCon -> SDoc

pprPrefixOcc :: DataCon -> SDoc

pprInfixOcc :: DataCon -> SDoc

bndrIsJoin_maybe :: DataCon -> Maybe Int

Outputable DataCon

Methods

ppr :: DataCon -> SDoc

pprPrec :: Rational -> DataCon -> SDoc

Uniquable DataCon

Methods

getUnique :: DataCon -> Unique

NamedThing DataCon

Methods

getOccName :: DataCon -> OccName

getName :: DataCon -> Name

data DataConRep

Data Constructor Representation

Constructors

NoDataConRep

DCR

Fields

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

data SrcStrictness

Source Strictness

What strictness annotation the user wrote

Constructors

SrcLazy

Lazy, ie '~'

SrcStrict

Strict, ie !

NoSrcStrict

no strictness annotation

Instances

Eq SrcStrictness

Methods

(==) :: SrcStrictness -> SrcStrictness -> Bool

(/=) :: SrcStrictness -> SrcStrictness -> Bool

Data SrcStrictness

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcStrictness -> c SrcStrictness

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

toConstr :: SrcStrictness -> Constr

dataTypeOf :: SrcStrictness -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable SrcStrictness

Methods

ppr :: SrcStrictness -> SDoc

pprPrec :: Rational -> SrcStrictness -> SDoc

Binary SrcStrictness

Methods

put_ :: BinHandle -> SrcStrictness -> IO ()

put :: BinHandle -> SrcStrictness -> IO (Bin * SrcStrictness)

get :: BinHandle -> IO SrcStrictness

data SrcUnpackedness

Source Unpackedness

What unpackedness the user requested

Constructors

SrcUnpack

{--} specified

SrcNoUnpack

{--} specified

NoSrcUnpack

no unpack pragma

Instances

Eq SrcUnpackedness

Methods

(==) :: SrcUnpackedness -> SrcUnpackedness -> Bool

(/=) :: SrcUnpackedness -> SrcUnpackedness -> Bool

Data SrcUnpackedness

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> SrcUnpackedness -> c SrcUnpackedness

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

toConstr :: SrcUnpackedness -> Constr

dataTypeOf :: SrcUnpackedness -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable SrcUnpackedness

Methods

ppr :: SrcUnpackedness -> SDoc

pprPrec :: Rational -> SrcUnpackedness -> SDoc

Binary SrcUnpackedness

Methods

put_ :: BinHandle -> SrcUnpackedness -> IO ()

put :: BinHandle -> SrcUnpackedness -> IO (Bin * SrcUnpackedness)

get :: BinHandle -> IO SrcUnpackedness

data HsSrcBang

Haskell Source Bang

Bangs on data constructor arguments as the user wrote them in the source code.

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

Constructors

HsSrcBang SourceText SrcUnpackedness SrcStrictness

Instances

Data HsSrcBang

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> HsSrcBang -> c HsSrcBang

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c HsSrcBang

toConstr :: HsSrcBang -> Constr

dataTypeOf :: HsSrcBang -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c HsSrcBang)

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c HsSrcBang)

gmapT :: (forall b. Data b => b -> b) -> HsSrcBang -> HsSrcBang

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> HsSrcBang -> r

gmapQ :: (forall d. Data d => d -> u) -> HsSrcBang -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> HsSrcBang -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> HsSrcBang -> m HsSrcBang

Outputable HsSrcBang

Methods

ppr :: HsSrcBang -> SDoc

pprPrec :: Rational -> HsSrcBang -> SDoc

data HsImplBang

Haskell Implementation Bang

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

Constructors

HsLazy

Lazy field

HsStrict

Strict but not unpacked field

HsUnpack (Maybe Coercion)

Strict and unpacked field co :: arg-ty ~ product-ty HsBang

Instances

Data HsImplBang

Methods

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

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

toConstr :: HsImplBang -> Constr

dataTypeOf :: HsImplBang -> DataType

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

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

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

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

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

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

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

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

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

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

Outputable HsImplBang

Methods

ppr :: HsImplBang -> SDoc

pprPrec :: Rational -> HsImplBang -> SDoc

data StrictnessMark

Constructors

MarkedStrict

NotMarkedStrict

Instances

Outputable StrictnessMark

Methods

ppr :: StrictnessMark -> SDoc

pprPrec :: Rational -> StrictnessMark -> SDoc

type ConTag = Int

Constructor Tag

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

Equality specs

data EqSpec

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

Instances

Outputable EqSpec

Methods

ppr :: EqSpec -> SDoc

pprPrec :: Rational -> EqSpec -> SDoc

mkEqSpec :: TyVar -> Type -> EqSpec

Make an EqSpec

eqSpecTyVar :: EqSpec -> TyVar

eqSpecType :: EqSpec -> Type

eqSpecPair :: EqSpec -> (TyVar, Type)

eqSpecPreds :: [EqSpec] -> ThetaType

substEqSpec :: TCvSubst -> EqSpec -> EqSpec

Substitute in an EqSpec. Precondition: if the LHS of the EqSpec is mapped in the substitution, it is mapped to a type variable, not a full type.

filterEqSpec :: [EqSpec] -> [TyVarBinder] -> [TyVarBinder]

Filter out any TyBinders mentioned in an EqSpec

Field labels

data FieldLbl a

Fields in an algebraic record type

Constructors

FieldLabel

Fields

• flLabel :: FieldLabelString

  User-visible label of the field

• flIsOverloaded :: Bool

  Was DuplicateRecordFields on in the defining module for this datatype?

• flSelector :: a

  Record selector function

Instances

Functor FieldLbl

Methods

fmap :: (a -> b) -> FieldLbl a -> FieldLbl b

(<$) :: a -> FieldLbl b -> FieldLbl a

Foldable FieldLbl

Methods

fold :: Monoid m => FieldLbl m -> m

foldMap :: Monoid m => (a -> m) -> FieldLbl a -> m

foldr :: (a -> b -> b) -> b -> FieldLbl a -> b

foldr' :: (a -> b -> b) -> b -> FieldLbl a -> b

foldl :: (b -> a -> b) -> b -> FieldLbl a -> b

foldl' :: (b -> a -> b) -> b -> FieldLbl a -> b

foldr1 :: (a -> a -> a) -> FieldLbl a -> a

foldl1 :: (a -> a -> a) -> FieldLbl a -> a

toList :: FieldLbl a -> [a]

null :: FieldLbl a -> Bool

length :: FieldLbl a -> Int

elem :: Eq a => a -> FieldLbl a -> Bool

maximum :: Ord a => FieldLbl a -> a

minimum :: Ord a => FieldLbl a -> a

sum :: Num a => FieldLbl a -> a

product :: Num a => FieldLbl a -> a

Traversable FieldLbl

Methods

traverse :: Applicative f => (a -> f b) -> FieldLbl a -> f (FieldLbl b)

sequenceA :: Applicative f => FieldLbl (f a) -> f (FieldLbl a)

mapM :: Monad m => (a -> m b) -> FieldLbl a -> m (FieldLbl b)

sequence :: Monad m => FieldLbl (m a) -> m (FieldLbl a)

Eq a => Eq (FieldLbl a)

Methods

(==) :: FieldLbl a -> FieldLbl a -> Bool

(/=) :: FieldLbl a -> FieldLbl a -> Bool

Data a => Data (FieldLbl a)

Methods

gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> FieldLbl a -> c (FieldLbl a)

gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c (FieldLbl a)

toConstr :: FieldLbl a -> Constr

dataTypeOf :: FieldLbl a -> DataType

dataCast1 :: Typeable (* -> *) t => (forall d. Data d => c (t d)) -> Maybe (c (FieldLbl a))

dataCast2 :: Typeable (* -> * -> *) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c (FieldLbl a))

gmapT :: (forall b. Data b => b -> b) -> FieldLbl a -> FieldLbl a

gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> FieldLbl a -> r

gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> FieldLbl a -> r

gmapQ :: (forall d. Data d => d -> u) -> FieldLbl a -> [u]

gmapQi :: Int -> (forall d. Data d => d -> u) -> FieldLbl a -> u

gmapM :: Monad m => (forall d. Data d => d -> m d) -> FieldLbl a -> m (FieldLbl a)

gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldLbl a -> m (FieldLbl a)

gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> FieldLbl a -> m (FieldLbl a)

Outputable a => Outputable (FieldLbl a)

Methods

ppr :: FieldLbl a -> SDoc

pprPrec :: Rational -> FieldLbl a -> SDoc

Binary a => Binary (FieldLbl a)

Methods

put_ :: BinHandle -> FieldLbl a -> IO ()

put :: BinHandle -> FieldLbl a -> IO (Bin * (FieldLbl a))

get :: BinHandle -> IO (FieldLbl a)

type FieldLabel = FieldLbl Name

type FieldLabelString = FastString

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

Type construction

mkDataCon

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

-> [TyVarBinder]

Universals. See Note [TyVarBinders in DataCons]

-> [TyVarBinder]

Existentials. (These last two must be Named and Inferred/Specified)

-> [EqSpec]

GADT equalities

-> ThetaType

Theta-type occuring before the arguments proper

-> [Type]

Original argument types

-> Type

Original result type

-> RuntimeRepInfo

See comments on RuntimeRepInfo

-> TyCon

Representation type constructor

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

buildAlgTyCon

Arguments

:: Name

-> [TyVar]

Kind variables and type variables

-> [Role]

-> Maybe CType

-> ThetaType

Stupid theta

-> AlgTyConRhs

-> Bool

True = was declared in GADT syntax

-> AlgTyConFlav

-> TyCon

buildSynTyCon

Arguments

:: Name

-> [TyConBinder]

-> Kind

result kind

-> [Role]

-> Type

-> TyCon

fIRST_TAG :: ConTag

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

Type deconstruction

dataConRepType :: DataCon -> Type

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

dataConSig :: DataCon -> ([TyVar], ThetaType, [Type], Type)

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

1) The result of dataConAllTyVars,

2) All the ThetaTypes relating to the DataCon (coercion, dictionary, implicit parameter - whatever)

3) The type arguments to the constructor

4) The original result type of the DataCon

dataConInstSig :: DataCon -> [Type] -> ([TyVar], ThetaType, [Type])

Instantantiate the universal tyvars of a data con, returning the instantiated existentials, constraints, and args

dataConFullSig :: DataCon -> ([TyVar], [TyVar], [EqSpec], ThetaType, [Type], Type)

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

1) The result of dataConUnivTyVars

2) The result of dataConExTyVars

3) The GADT equalities

4) The result of dataConDictTheta

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

6) The original result type of the DataCon

dataConName :: DataCon -> Name

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

dataConIdentity :: DataCon -> [Word8]

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

The tag used for ordering DataCons

dataConTyCon :: DataCon -> TyCon

The type constructor that we are building via this data constructor

dataConOrigTyCon :: DataCon -> TyCon

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.

dataConUserType :: DataCon -> Type

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

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

dataConUnivTyVars :: DataCon -> [TyVar]

The universally-quantified type variables of the constructor

dataConUnivTyVarBinders :: DataCon -> [TyVarBinder]

TyBinders for the universally-quantified type variables

dataConExTyVars :: DataCon -> [TyVar]

The existentially-quantified type variables of the constructor

dataConExTyVarBinders :: DataCon -> [TyVarBinder]

TyBinders for the existentially-quantified type variables

dataConAllTyVars :: DataCon -> [TyVar]

Both the universal and existentiatial type variables of the constructor

dataConEqSpec :: DataCon -> [EqSpec]

Equalities derived from the result type of the data constructor, as written by the programmer in any GADT declaration. This includes *all* GADT-like equalities, including those written in by hand by the programmer.

dataConTheta :: DataCon -> ThetaType

The *full* constraints on the constructor type.

dataConStupidTheta :: DataCon -> ThetaType

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

data Eq a => T a = ...

dataConInstArgTys

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

-> [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 -> [Type]

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

dataConOrigResTy :: DataCon -> Type

dataConInstOrigArgTys :: DataCon -> [Type] -> [Type]

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

dataConRepArgTys :: DataCon -> [Type]

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

dataConFieldLabels :: DataCon -> [FieldLabel]

The labels for the fields of this particular DataCon

dataConFieldType :: DataCon -> FieldLabelString -> Type

Extract the type for any given labelled field of the DataCon

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

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]

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-level arity of the data constructor

dataConRepArity :: DataCon -> Arity

Gives the number of actual fields in the representation of the data constructor. This may be more than appear in the source code; the extra ones are the existentially quantified dictionaries

dataConIsInfix :: DataCon -> Bool

Should the DataCon be presented infix?

dataConWorkId :: DataCon -> Id

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

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

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]

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

dataConRepStrictness :: DataCon -> [StrictnessMark]

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

dataConImplBangs :: DataCon -> [HsImplBang]

dataConBoxer :: DataCon -> Maybe DataConBoxer

splitDataProductType_maybe

Arguments

:: Type

A product type, perhaps

-> Maybe (TyCon, [Type], DataCon, [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 type that is all of:

• Concrete (i.e. constructors visible)
• Single-constructor
• Not existentially quantified

Whether the type is a data type or a newtype

Predicates on DataCons

isNullarySrcDataCon :: DataCon -> Bool

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

isNullaryRepDataCon :: DataCon -> Bool

Return whether there are any argument types for this DataCons runtime representation type See Note [DataCon arities]

isTupleDataCon :: DataCon -> Bool

isUnboxedTupleCon :: DataCon -> Bool

isUnboxedSumCon :: DataCon -> Bool

isVanillaDataCon :: DataCon -> Bool

Vanilla DataCons are those that are nice boring Haskell 98 constructors

classDataCon :: Class -> DataCon

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

isBanged :: HsImplBang -> Bool

isMarkedStrict :: StrictnessMark -> Bool

eqHsBang :: HsImplBang -> HsImplBang -> Bool

Compare strictness annotations

isSrcStrict :: SrcStrictness -> Bool

isSrcUnpacked :: SrcUnpackedness -> Bool

specialPromotedDc :: DataCon -> Bool

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

isLegacyPromotableDataCon :: DataCon -> Bool

Was this datacon promotable before GHC 8.0? That is, is it promotable without -XTypeInType

isLegacyPromotableTyCon :: TyCon -> Bool

Was this tycon promotable before GHC 8.0? That is, is it promotable without -XTypeInType

Promotion related functions

promoteDataCon :: DataCon -> TyCon