TyCon

ghc-8.0.0.20160204: The GHC API

Safe Haskell | None
Language | Haskell2010

TyCon

Contents

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

Synopsis

- data TyCon
- data AlgTyConRhs
  - = AbstractTyCon Bool
  - | DataTyCon {
    - data_cons :: [DataCon]
    - is_enum :: Bool
    }
  - | TupleTyCon {
    - data_con :: DataCon
    - tup_sort :: TupleSort
    }
  - | NewTyCon {
    - data_con :: DataCon
    - nt_rhs :: Type
    - nt_etad_rhs :: ([TyVar], Type)
    - nt_co :: CoAxiom Unbranched
    }
- visibleDataCons :: AlgTyConRhs -> [DataCon]
- data AlgTyConFlav
  - = VanillaAlgTyCon TyConRepName
  - | UnboxedAlgTyCon
  - | ClassTyCon Class TyConRepName
  - | DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type]
- isNoParent :: AlgTyConFlav -> Bool
- data FamTyConFlav
  - = DataFamilyTyCon TyConRepName
  - | OpenSynFamilyTyCon
  - | ClosedSynFamilyTyCon (Maybe (CoAxiom Branched))
  - | AbstractClosedSynFamilyTyCon
  - | BuiltInSynFamTyCon BuiltInSynFamily
- data Role
  - = Nominal
  - | Representational
  - | Phantom
- data Injectivity
  - = NotInjective
  - | Injective [Bool]
- tyConFieldLabels :: TyCon -> [FieldLabel]
- tyConFieldLabelEnv :: TyCon -> FieldLabelEnv
- mkAlgTyCon :: Name -> Kind -> [TyVar] -> [Role] -> Maybe CType -> [PredType] -> AlgTyConRhs -> AlgTyConFlav -> RecFlag -> Bool -> TyCon
- mkClassTyCon :: Name -> Kind -> [TyVar] -> [Role] -> AlgTyConRhs -> Class -> RecFlag -> Name -> TyCon
- mkFunTyCon :: Name -> Kind -> Name -> TyCon
- mkPrimTyCon :: Name -> Kind -> [Role] -> PrimRep -> TyCon
- mkKindTyCon :: Name -> Kind -> [Role] -> Name -> TyCon
- mkLiftedPrimTyCon :: Name -> Kind -> [Role] -> PrimRep -> TyCon
- mkTupleTyCon :: Name -> Kind -> Arity -> [TyVar] -> DataCon -> TupleSort -> AlgTyConFlav -> TyCon
- mkSynonymTyCon :: Name -> Kind -> [TyVar] -> [Role] -> Type -> TyCon
- mkFamilyTyCon :: Name -> Kind -> [TyVar] -> Maybe Name -> FamTyConFlav -> Maybe Class -> Injectivity -> TyCon
- mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> Kind -> [Role] -> TyCon
- mkTcTyCon :: Name -> Kind -> TyCon
- isAlgTyCon :: TyCon -> Bool
- isVanillaAlgTyCon :: TyCon -> Bool
- isClassTyCon :: TyCon -> Bool
- isFamInstTyCon :: TyCon -> Bool
- isFunTyCon :: TyCon -> Bool
- isPrimTyCon :: TyCon -> Bool
- isTupleTyCon :: TyCon -> Bool
- isUnboxedTupleTyCon :: TyCon -> Bool
- isBoxedTupleTyCon :: TyCon -> Bool
- isTypeSynonymTyCon :: TyCon -> Bool
- mightBeUnsaturatedTyCon :: TyCon -> Bool
- isPromotedDataCon :: TyCon -> Bool
- isPromotedDataCon_maybe :: TyCon -> Maybe DataCon
- isKindTyCon :: TyCon -> Bool
- isLiftedTypeKindTyConName :: Name -> Bool
- isDataTyCon :: TyCon -> Bool
- isProductTyCon :: TyCon -> Bool
- isDataProductTyCon_maybe :: TyCon -> Maybe DataCon
- isEnumerationTyCon :: TyCon -> Bool
- isNewTyCon :: TyCon -> Bool
- isAbstractTyCon :: TyCon -> Bool
- isFamilyTyCon :: TyCon -> Bool
- isOpenFamilyTyCon :: TyCon -> Bool
- isTypeFamilyTyCon :: TyCon -> Bool
- isDataFamilyTyCon :: TyCon -> Bool
- isOpenTypeFamilyTyCon :: TyCon -> Bool
- isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched)
- familyTyConInjectivityInfo :: TyCon -> Injectivity
- isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily
- isUnLiftedTyCon :: TyCon -> Bool
- isGadtSyntaxTyCon :: TyCon -> Bool
- isInjectiveTyCon :: TyCon -> Role -> Bool
- isGenerativeTyCon :: TyCon -> Role -> Bool
- isGenInjAlgRhs :: AlgTyConRhs -> Bool
- isTyConAssoc :: TyCon -> Bool
- tyConAssoc_maybe :: TyCon -> Maybe Class
- isRecursiveTyCon :: TyCon -> Bool
- isImplicitTyCon :: TyCon -> Bool
- isTyConWithSrcDataCons :: TyCon -> Bool
- isTcTyCon :: TyCon -> Bool
- tyConName :: TyCon -> Name
- tyConKind :: TyCon -> Kind
- tyConUnique :: TyCon -> Unique
- tyConTyVars :: TyCon -> [TyVar]
- tyConCType :: TyCon -> Maybe CType
- tyConCType_maybe :: TyCon -> Maybe CType
- tyConDataCons :: TyCon -> [DataCon]
- tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
- tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
- tyConSingleDataCon :: TyCon -> DataCon
- tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon
- tyConFamilySize :: TyCon -> Int
- tyConStupidTheta :: TyCon -> [PredType]
- tyConArity :: TyCon -> Arity
- tyConRoles :: TyCon -> [Role]
- tyConFlavour :: TyCon -> String
- tyConTuple_maybe :: TyCon -> Maybe TupleSort
- tyConClass_maybe :: TyCon -> Maybe Class
- tyConATs :: TyCon -> [TyCon]
- tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
- tyConFamInstSig_maybe :: TyCon -> Maybe (TyCon, [Type], CoAxiom Unbranched)
- tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
- tyConFamilyResVar_maybe :: TyCon -> Maybe Name
- synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type)
- synTyConRhs_maybe :: TyCon -> Maybe Type
- famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav
- famTcResVar :: TyCon -> Maybe Name
- algTyConRhs :: TyCon -> AlgTyConRhs
- newTyConRhs :: TyCon -> ([TyVar], Type)
- newTyConEtadArity :: TyCon -> Int
- newTyConEtadRhs :: TyCon -> ([TyVar], Type)
- unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
- unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched)
- algTcFields :: TyCon -> FieldLabelEnv
- expandSynTyCon_maybe :: TyCon -> [tyco] -> Maybe ([(TyVar, tyco)], Type, [tyco])
- makeTyConAbstract :: TyCon -> TyCon
- newTyConCo :: TyCon -> CoAxiom Unbranched
- newTyConCo_maybe :: TyCon -> Maybe (CoAxiom Unbranched)
- pprPromotionQuote :: TyCon -> SDoc
- type TyConRepName = Name
- tyConRepName_maybe :: TyCon -> Maybe TyConRepName
- mkPrelTyConRepName :: Name -> TyConRepName
- tyConRepModOcc :: Module -> OccName -> (Module, OccName)
- data PrimRep
  - = VoidRep
  - | PtrRep
  - | IntRep
  - | WordRep
  - | Int64Rep
  - | Word64Rep
  - | AddrRep
  - | FloatRep
  - | DoubleRep
  - | VecRep Int PrimElemRep
- data PrimElemRep
  - = Int8ElemRep
  - | Int16ElemRep
  - | Int32ElemRep
  - | Int64ElemRep
  - | Word8ElemRep
  - | Word16ElemRep
  - | Word32ElemRep
  - | Word64ElemRep
  - | FloatElemRep
  - | DoubleElemRep
- tyConPrimRep :: TyCon -> PrimRep
- isVoidRep :: PrimRep -> Bool
- isGcPtrRep :: PrimRep -> Bool
- primRepSizeW :: DynFlags -> PrimRep -> Int
- primElemRepSizeB :: PrimElemRep -> Int
- primRepIsFloat :: PrimRep -> Maybe Bool
- data RecTcChecker
- initRecTc :: RecTcChecker
- checkRecTc :: RecTcChecker -> TyCon -> Maybe RecTcChecker

# Main TyCon data types

data TyCon Source

TyCons represent type constructors. Type constructors are introduced by things such as:

1) Data declarations: `data Foo = ...` creates the `Foo` type constructor of kind `*`

2) Type synonyms: `type Foo = ...` creates the `Foo` type constructor

3) Newtypes: `newtype Foo a = MkFoo ...` creates the `Foo` type constructor of kind `* -> *`

4) Class declarations: `class Foo where` creates the `Foo` type constructor of kind `*`

This data type also encodes a number of primitive, built in type constructors such as those for function and tuple types.

Instances

Eq TyCon |
Methods (==) :: TyCon -> TyCon -> Bool (/=) :: TyCon -> TyCon -> Bool
Data TyCon |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> TyCon -> c TyCon Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c TyCon Source toConstr :: TyCon -> Constr Source dataTypeOf :: TyCon -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c TyCon) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c TyCon) Source gmapT :: (forall b. Data b => b -> b) -> TyCon -> TyCon Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> TyCon -> r Source gmapQ :: (forall d. Data d => d -> u) -> TyCon -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> TyCon -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> TyCon -> m TyCon Source
Ord TyCon |
Methods compare :: TyCon -> TyCon -> Ordering (<) :: TyCon -> TyCon -> Bool (<=) :: TyCon -> TyCon -> Bool (>) :: TyCon -> TyCon -> Bool (>=) :: TyCon -> TyCon -> Bool max :: TyCon -> TyCon -> TyCon min :: TyCon -> TyCon -> TyCon
Outputable TyCon |
Methods ppr :: TyCon -> SDoc Source pprPrec :: Rational -> TyCon -> SDoc Source
Uniquable TyCon |
Methods getUnique :: TyCon -> Unique Source
NamedThing TyCon |
Methods getOccName :: TyCon -> OccName Source getName :: TyCon -> Name Source

data AlgTyConRhs Source

Represents right-hand-sides of `TyCon`s for algebraic types

Constructors

AbstractTyCon Bool | Says that we know nothing about this data type, except that it's represented by a pointer. Used when we export a data type abstractly into an .hi file.
DataTyCon | Information about those `TyCon`s derived from a `data` declaration. This includes data types with no constructors at all.
Fields data_cons :: [DataCon] The data type constructors; can be empty if the user declares the type to have no constructors INVARIANT: Kept in order of increasing `DataCon` tag (see the tag assignment in DataCon.mkDataCon) is_enum :: Bool Cached value: is this an enumeration type? See Note [Enumeration types]
TupleTyCon |
Fields data_con :: DataCon The unique constructor for the `newtype`. It has no existentials tup_sort :: TupleSort Is this a boxed, unboxed or constraint tuple?
NewTyCon | Information about those `TyCon`s derived from a `newtype` declaration
Fields data_con :: DataCon The unique constructor for the `newtype`. It has no existentials nt_rhs :: Type Cached value: the argument type of the constructor, which is just the representation type of the `TyCon` (remember that `newtype`s do not exist at runtime so need a different representation type). The free `TyVar`s of this type are the `tyConTyVars` from the corresponding `TyCon` nt_etad_rhs :: ([TyVar], Type) Same as the `nt_rhs`, but this time eta-reduced. Hence the list of `TyVar`s in this field may be shorter than the declared arity of the `TyCon`. nt_co :: CoAxiom Unbranched

visibleDataCons :: AlgTyConRhs -> [DataCon] Source

Both type classes as well as family instances imply implicit type constructors. These implicit type constructors refer to their parent structure (ie, the class or family from which they derive) using a type of the following form.

Extract those `DataCon`s that we are able to learn about. Note that visibility in this sense does not correspond to visibility in the context of any particular user program!

data AlgTyConFlav Source

Constructors

VanillaAlgTyCon TyConRepName | An ordinary type constructor has no parent.
UnboxedAlgTyCon | An unboxed type constructor. Note that this carries no TyConRepName as it is not representable.
ClassTyCon Class TyConRepName | Type constructors representing a class dictionary. See Note [ATyCon for classes] in TyCoRep
DataFamInstTyCon (CoAxiom Unbranched) TyCon [Type] | Type constructors representing an *instance* of a *data* family. Parameters: 1) The type family in question 2) Instance types; free variables are the `tyConTyVars` of the current `TyCon` (not the family one). INVARIANT: the number of types matches the arity of the family `TyCon` 3) A `CoTyCon` identifying the representation type with the type instance family

Instances

Outputable AlgTyConFlav |
Methods ppr :: AlgTyConFlav -> SDoc Source pprPrec :: Rational -> AlgTyConFlav -> SDoc Source

isNoParent :: AlgTyConFlav -> Bool Source

data FamTyConFlav Source

Information pertaining to the expansion of a type synonym (`type`)

Constructors

DataFamilyTyCon TyConRepName | Represents an open type family without a fixed right hand side. Additional instances can appear at any time. These are introduced by either a top level declaration:
    data family T a :: *
Or an associated data type declaration, within a class declaration:
    class C a b where
      data T b :: *
OpenSynFamilyTyCon | An open type synonym family e.g. `type family F x y :: * -> *`
ClosedSynFamilyTyCon (Maybe (CoAxiom Branched)) | A closed type synonym family e.g. `type family F x where { F Int = Bool }`
AbstractClosedSynFamilyTyCon | A closed type synonym family declared in an hs-boot file with type family F a where ..
BuiltInSynFamTyCon BuiltInSynFamily | Built-in type family used by the TypeNats solver

data Role Source

Constructors

Nominal |
Representational |
Phantom |

Instances

Eq Role |
Methods (==) :: Role -> Role -> Bool (/=) :: Role -> Role -> Bool
Data Role |
Methods gfoldl :: (forall d b. Data d => c (d -> b) -> d -> c b) -> (forall g. g -> c g) -> Role -> c Role Source gunfold :: (forall b r. Data b => c (b -> r) -> c r) -> (forall r. r -> c r) -> Constr -> c Role Source toConstr :: Role -> Constr Source dataTypeOf :: Role -> DataType Source dataCast1 :: Typeable (TYPE Lifted -> TYPE Lifted) t => (forall d. Data d => c (t d)) -> Maybe (c Role) Source dataCast2 :: Typeable (TYPE Lifted -> TYPE Lifted -> TYPE Lifted) t => (forall d e. (Data d, Data e) => c (t d e)) -> Maybe (c Role) Source gmapT :: (forall b. Data b => b -> b) -> Role -> Role Source gmapQl :: (r -> r' -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source gmapQr :: (r' -> r -> r) -> r -> (forall d. Data d => d -> r') -> Role -> r Source gmapQ :: (forall d. Data d => d -> u) -> Role -> [u] Source gmapQi :: Int -> (forall d. Data d => d -> u) -> Role -> u Source gmapM :: Monad m => (forall d. Data d => d -> m d) -> Role -> m Role Source gmapMp :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source gmapMo :: MonadPlus m => (forall d. Data d => d -> m d) -> Role -> m Role Source
Ord Role |
Methods compare :: Role -> Role -> Ordering (<) :: Role -> Role -> Bool (<=) :: Role -> Role -> Bool (>) :: Role -> Role -> Bool (>=) :: Role -> Role -> Bool max :: Role -> Role -> Role min :: Role -> Role -> Role
Outputable Role |
Methods ppr :: Role -> SDoc Source pprPrec :: Rational -> Role -> SDoc Source
Binary Role |
Methods put_ :: BinHandle -> Role -> IO () Source put :: BinHandle -> Role -> IO (Bin Role) Source get :: BinHandle -> IO Role Source

data Injectivity Source

Constructors

NotInjective |
Injective [Bool] |

Instances

Eq Injectivity |
Methods (==) :: Injectivity -> Injectivity -> Bool (/=) :: Injectivity -> Injectivity -> Bool
Binary Injectivity |
Methods put_ :: BinHandle -> Injectivity -> IO () Source put :: BinHandle -> Injectivity -> IO (Bin Injectivity) Source get :: BinHandle -> IO Injectivity Source

## Field labels

tyConFieldLabels :: TyCon -> [FieldLabel] Source

The labels for the fields of this particular `TyCon`

tyConFieldLabelEnv :: TyCon -> FieldLabelEnv Source

The labels for the fields of this particular `TyCon`

## Constructing TyCons

mkAlgTyCon Source

Arguments

:: Name |
-> Kind | Kind of the resulting `TyCon`
-> [TyVar] | `TyVar`s scoped over: see `tyConTyVars`. Arity is inferred from the length of this list
-> [Role] | The roles for each TyVar
-> Maybe CType | The C type this type corresponds to when using the CAPI FFI
-> [PredType] | Stupid theta: see `algTcStupidTheta`
-> AlgTyConRhs | Information about data constructors
-> AlgTyConFlav | What flavour is it? (e.g. vanilla, type family)
-> RecFlag | Is the `TyCon` recursive?
-> Bool | Was the `TyCon` declared with GADT syntax?
-> TyCon |

This is the making of an algebraic `TyCon`. Notably, you have to pass in the generic (in the -XGenerics sense) information about the type constructor - you can get hold of it easily (see Generics module)

mkClassTyCon :: Name -> Kind -> [TyVar] -> [Role] -> AlgTyConRhs -> Class -> RecFlag -> Name -> TyCon Source

Simpler specialization of `mkAlgTyCon` for classes

mkFunTyCon :: Name -> Kind -> Name -> TyCon Source

Given the name of the function type constructor and it's kind, create the corresponding `TyCon`. It is reccomended to use `funTyCon` if you want this functionality

mkPrimTyCon :: Name -> Kind -> [Role] -> PrimRep -> TyCon Source

Create an unlifted primitive `TyCon`, such as `Int#`

mkKindTyCon :: Name -> Kind -> [Role] -> Name -> TyCon Source

Kind constructors

mkLiftedPrimTyCon :: Name -> Kind -> [Role] -> PrimRep -> TyCon Source

Create a lifted primitive `TyCon` such as `RealWorld`

mkTupleTyCon Source

Arguments

:: Name |
-> Kind | Kind of the resulting `TyCon`
-> Arity | Arity of the tuple
-> [TyVar] | `TyVar`s scoped over: see `tyConTyVars`
-> DataCon |
-> TupleSort | Whether the tuple is boxed or unboxed
-> AlgTyConFlav |
-> TyCon |

mkSynonymTyCon :: Name -> Kind -> [TyVar] -> [Role] -> Type -> TyCon Source

Create a type synonym `TyCon`

mkFamilyTyCon :: Name -> Kind -> [TyVar] -> Maybe Name -> FamTyConFlav -> Maybe Class -> Injectivity -> TyCon Source

Create a type family `TyCon`

mkPromotedDataCon :: DataCon -> Name -> TyConRepName -> Kind -> [Role] -> TyCon Source

Create a promoted data constructor `TyCon` Somewhat dodgily, we give it the same Name as the data constructor itself; when we pretty-print the TyCon we add a quote; see the Outputable TyCon instance

mkTcTyCon :: Name -> Kind -> TyCon Source

Makes a tycon suitable for use during type-checking. The only real need for this is for printing error messages during a recursive type/class type-checking knot. It has a kind because TcErrors sometimes calls typeKind. See also Note [Kind checking recursive type and class declarations] in TcTyClsDecls.

## Predicates on TyCons

isAlgTyCon :: TyCon -> Bool Source

Returns `True` if the supplied `TyCon` resulted from either a `data` or `newtype` declaration

isVanillaAlgTyCon :: TyCon -> Bool Source

Returns `True` for vanilla AlgTyCons -- that is, those created with a `data` or `newtype` declaration.

isClassTyCon :: TyCon -> Bool Source

Is this `TyCon` that for a class instance?

isFamInstTyCon :: TyCon -> Bool Source

Is this `TyCon` that for a data family instance?

isFunTyCon :: TyCon -> Bool Source

isPrimTyCon :: TyCon -> Bool Source

Does this `TyCon` represent something that cannot be defined in Haskell?

isTupleTyCon :: TyCon -> Bool Source

Does this `TyCon` represent a tuple?

NB: when compiling `Data.Tuple`, the tycons won't reply `True` to `isTupleTyCon`, because they are built as `AlgTyCons`. However they get spat into the interface file as tuple tycons, so I don't think it matters.

isUnboxedTupleTyCon :: TyCon -> Bool Source

Is this the `TyCon` for an unboxed tuple?

isBoxedTupleTyCon :: TyCon -> Bool Source

Is this the `TyCon` for a boxed tuple?

isTypeSynonymTyCon :: TyCon -> Bool Source

Is this a `TyCon` representing a regular H98 type synonym (`type`)?

mightBeUnsaturatedTyCon :: TyCon -> Bool Source

True iff we can decompose (T a b c) into ((T a b) c) I.e. is it injective and generative w.r.t nominal equality? That is, if (T a b) ~N d e f, is it always the case that (T ~N d), (a ~N e) and (b ~N f)? Specifically NOT true of synonyms (open and otherwise)

It'd be unusual to call mightBeUnsaturatedTyCon on a regular H98 type synonym, because you should probably have expanded it first But regardless, it's not decomposable

isPromotedDataCon :: TyCon -> Bool Source

Is this a PromotedDataCon?

isPromotedDataCon_maybe :: TyCon -> Maybe DataCon Source

Retrieves the promoted DataCon if this is a PromotedDataCon;

isKindTyCon :: TyCon -> Bool Source

Is this tycon really meant for use at the kind level? That is, should it be permitted without -XDataKinds?

isLiftedTypeKindTyConName :: Name -> Bool Source

isDataTyCon :: TyCon -> Bool Source

Returns `True` for data types that are definitely represented by heap-allocated constructors. These are scrutinised by Core-level `case` expressions, and they get info tables allocated for them.

Generally, the function will be true for all `data` types and false for `newtype`s, unboxed tuples and type family `TyCon`s. But it is not guaranteed to return `True` in all cases that it could.

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

isProductTyCon :: TyCon -> Bool Source

isDataProductTyCon_maybe :: TyCon -> Maybe DataCon Source

isEnumerationTyCon :: TyCon -> Bool Source

Is this an algebraic `TyCon` which is just an enumeration of values?

isNewTyCon :: TyCon -> Bool Source

Is this `TyCon` that for a `newtype`

isAbstractTyCon :: TyCon -> Bool Source

Test if the `TyCon` is algebraic but abstract (invisible data constructors)

isFamilyTyCon :: TyCon -> Bool Source

Is this a `TyCon`, synonym or otherwise, that defines a family?

isOpenFamilyTyCon :: TyCon -> Bool Source

Is this a `TyCon`, synonym or otherwise, that defines a family with instances?

isTypeFamilyTyCon :: TyCon -> Bool Source

Is this a synonym `TyCon` that can have may have further instances appear?

isDataFamilyTyCon :: TyCon -> Bool Source

Is this a synonym `TyCon` that can have may have further instances appear?

isOpenTypeFamilyTyCon :: TyCon -> Bool Source

Is this an open type family TyCon?

isClosedSynFamilyTyConWithAxiom_maybe :: TyCon -> Maybe (CoAxiom Branched) Source

Is this a non-empty closed type family? Returns `Nothing` for abstract or empty closed families.

familyTyConInjectivityInfo :: TyCon -> Injectivity Source

Try to read the injectivity information from a FamilyTyCon. For every other TyCon this function panics.

isBuiltInSynFamTyCon_maybe :: TyCon -> Maybe BuiltInSynFamily Source

isUnLiftedTyCon :: TyCon -> Bool Source

Is this `TyCon` unlifted (i.e. cannot contain bottom)? Note that this can only be true for primitive and unboxed-tuple `TyCon`s

isGadtSyntaxTyCon :: TyCon -> Bool Source

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

isInjectiveTyCon :: TyCon -> Role -> Bool Source

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

isGenerativeTyCon :: TyCon -> Role -> Bool Source

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

isGenInjAlgRhs :: AlgTyConRhs -> Bool Source

Is this an `AlgTyConRhs` of a `TyCon` that is generative and injective with respect to representational equality?

isTyConAssoc :: TyCon -> Bool Source

Are we able to extract information `TyVar` to class argument list mapping from a given `TyCon`?

tyConAssoc_maybe :: TyCon -> Maybe Class Source

isRecursiveTyCon :: TyCon -> Bool Source

Is this a recursive `TyCon`?

isImplicitTyCon :: TyCon -> Bool Source

Identifies implicit tycons that, in particular, do not go into interface files (because they are implicitly reconstructed when the interface is read).

Note that:

- Associated families are implicit, as they are re-constructed from the class declaration in which they reside, and
- Family instances are not implicit as they represent the instance body (similar to a `dfun` does that for a class instance).
- Tuples are implicit iff they have a wired-in name (namely: boxed and unboxed tupeles are wired-in and implicit, but constraint tuples are not)

isTyConWithSrcDataCons :: TyCon -> Bool Source

Check if the tycon actually refers to a proper `data` or `newtype` with user defined constructors rather than one from a class or other construction.

isTcTyCon :: TyCon -> Bool Source

Is this a TcTyCon? (That is, one only used during type-checking?)

## Extracting information out of TyCons

tyConName :: TyCon -> Name Source

Name of the constructor

tyConKind :: TyCon -> Kind Source

Kind of this TyCon (full kind, not just the return kind)

tyConUnique :: TyCon -> Unique Source

A Unique of this TyCon. Invariant: identical to Unique of Name stored in tyConName field.

tyConTyVars :: TyCon -> [TyVar] Source

The kind and type variables used in the type constructor. Invariant: length tyvars = arity Precisely, this list scopes over:

1. The `algTcStupidTheta`
2. The cached types in algTyConRhs.NewTyCon
3. The family instance types if present

Note that it does not scope over the data constructors.

tyConCType :: TyCon -> Maybe CType Source

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

tyConCType_maybe :: TyCon -> Maybe CType Source

tyConDataCons :: TyCon -> [DataCon] Source

As `tyConDataCons_maybe`, but returns the empty list of constructors if no constructors could be found

tyConDataCons_maybe :: TyCon -> Maybe [DataCon] Source

Determine the `DataCon`s originating from the given `TyCon`, if the `TyCon` is the sort that can have any constructors (note: this does not include abstract algebraic types)

tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon Source

If the given `TyCon` has a single data constructor, i.e. it is a `data` type with one alternative, a tuple type or a `newtype` then that constructor is returned. If the `TyCon` has more than one constructor, or represents a primitive or function type constructor then `Nothing` is returned. In any other case, the function panics

tyConSingleDataCon :: TyCon -> DataCon Source

tyConSingleAlgDataCon_maybe :: TyCon -> Maybe DataCon Source

tyConFamilySize :: TyCon -> Int Source

Determine the number of value constructors a `TyCon` has. Panics if the `TyCon` is not algebraic or a tuple

tyConStupidTheta :: TyCon -> [PredType] Source

Find the "stupid theta" of the `TyCon`. A "stupid theta" is the context to the left of an algebraic type declaration, e.g. `Eq a` in the declaration `data Eq a => T a ...`

tyConArity :: TyCon -> Arity Source

Number of arguments this TyCon must receive to be considered saturated (including implicit kind variables)

tyConRoles :: TyCon -> [Role] Source

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

tyConFlavour :: TyCon -> String Source

tyConTuple_maybe :: TyCon -> Maybe TupleSort Source

tyConClass_maybe :: TyCon -> Maybe Class Source

If this `TyCon` is that for a class instance, return the class it is for. Otherwise returns `Nothing`

tyConATs :: TyCon -> [TyCon] Source

Return the associated types of the `TyCon`, if any

tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type]) Source

If this `TyCon` is that of a data family instance, return the family in question and the instance types. Otherwise, return `Nothing`

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

tyConFamilyCoercion_maybe :: TyCon -> Maybe (CoAxiom Unbranched) Source

If this `TyCon` is that of a data family instance, return a `TyCon` which represents a coercion identifying the representation type with the type instance family. Otherwise, return `Nothing`

tyConFamilyResVar_maybe :: TyCon -> Maybe Name Source

Extract type variable naming the result of injective type family

synTyConDefn_maybe :: TyCon -> Maybe ([TyVar], Type) Source

Extract the `TyVar`s bound by a vanilla type synonym and the corresponding (unsubstituted) right hand side.

synTyConRhs_maybe :: TyCon -> Maybe Type Source

Extract the information pertaining to the right hand side of a type synonym (`type`) declaration.

famTyConFlav_maybe :: TyCon -> Maybe FamTyConFlav Source

Extract the flavour of a type family (with all the extra information that it carries)

famTcResVar :: TyCon -> Maybe Name Source

Name of result type variable, used for pretty-printing with --show-iface and for reifying TyCon in Template Haskell

algTyConRhs :: TyCon -> AlgTyConRhs Source

Extract an `AlgTyConRhs` with information about data constructors from an algebraic or tuple `TyCon`. Panics for any other sort of `TyCon`

newTyConRhs :: TyCon -> ([TyVar], Type) Source

Extract the bound type variables and type expansion of a type synonym `TyCon`. Panics if the `TyCon` is not a synonym

newTyConEtadArity :: TyCon -> Int Source

The number of type parameters that need to be passed to a newtype to resolve it. May be less than in the definition if it can be eta-contracted.

newTyConEtadRhs :: TyCon -> ([TyVar], Type) Source

Extract the bound type variables and type expansion of an eta-contracted type synonym `TyCon`. Panics if the `TyCon` is not a synonym

unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched) Source

Take a `TyCon` apart into the `TyVar`s it scopes over, the `Type` it expands into, and (possibly) a coercion from the representation type to the `newtype`. Returns `Nothing` if this is not possible.

unwrapNewTyConEtad_maybe :: TyCon -> Maybe ([TyVar], Type, CoAxiom Unbranched) Source

algTcFields :: TyCon -> FieldLabelEnv Source

Maps a label to information about the field

## Manipulating TyCons

expandSynTyCon_maybe Source

Arguments

:: TyCon |
-> [tyco] | Arguments to `TyCon`
-> Maybe ([(TyVar, tyco)], Type, [tyco]) | Returns a `TyVar` substitution, the body type of the synonym (not yet substituted) and any arguments remaining from the application

Expand a type synonym application, if any

makeTyConAbstract :: TyCon -> TyCon Source

Make an fake, abstract `TyCon` from an existing one. Used when recovering from errors

newTyConCo :: TyCon -> CoAxiom Unbranched Source

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

Extracts the `newtype` coercion from such a `TyCon`, which can be used to construct something with the `newtype`s type from its representation type (right hand side). If the supplied `TyCon` is not a `newtype`, returns `Nothing`

pprPromotionQuote :: TyCon -> SDoc Source

# Runtime type representation

type TyConRepName = Name Source

tyConRepName_maybe :: TyCon -> Maybe TyConRepName Source

mkPrelTyConRepName :: Name -> TyConRepName Source

Make a `Name` for the `Typeable` representation of the given wired-in type

tyConRepModOcc :: Module -> OccName -> (Module, OccName) Source

The name (and defining module) for the Typeable representation (TyCon) of a type constructor.

See Note [Grand plan for Typeable] in `TcTypeable` in TcTypeable.

# Primitive representations of Types

data PrimRep Source

A `PrimRep` is an abstraction of a type. It contains information that the code generator needs in order to pass arguments, return results, and store values of this type.

Constructors

VoidRep |
PtrRep |
IntRep | Signed, word-sized value
WordRep | Unsigned, word-sized value
Int64Rep | Signed, 64 bit value (with 32-bit words only)
Word64Rep | Unsigned, 64 bit value (with 32-bit words only)
AddrRep | A pointer, but not to a Haskell value (use `PtrRep`)
FloatRep |
DoubleRep |
VecRep Int PrimElemRep | A vector

Instances

Eq PrimRep |
Methods (==) :: PrimRep -> PrimRep -> Bool (/=) :: PrimRep -> PrimRep -> Bool
Show PrimRep |
Methods showsPrec :: Int -> PrimRep -> ShowS Source show :: PrimRep -> String Source showList :: [PrimRep] -> ShowS Source
Outputable PrimRep |
Methods ppr :: PrimRep -> SDoc Source pprPrec :: Rational -> PrimRep -> SDoc Source

data PrimElemRep Source

Constructors

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

Instances

Eq PrimElemRep |
Methods (==) :: PrimElemRep -> PrimElemRep -> Bool (/=) :: PrimElemRep -> PrimElemRep -> Bool
Show PrimElemRep |
Methods showsPrec :: Int -> PrimElemRep -> ShowS Source show :: PrimElemRep -> String Source showList :: [PrimElemRep] -> ShowS Source
Outputable PrimElemRep |
Methods ppr :: PrimElemRep -> SDoc Source pprPrec :: Rational -> PrimElemRep -> SDoc Source

tyConPrimRep :: TyCon -> PrimRep Source

Find the primitive representation of a `TyCon`

isVoidRep :: PrimRep -> Bool Source

isGcPtrRep :: PrimRep -> Bool Source

primRepSizeW :: DynFlags -> PrimRep -> Int Source

Find the size of a `PrimRep`, in words

primElemRepSizeB :: PrimElemRep -> Int Source

primRepIsFloat :: PrimRep -> Maybe Bool Source

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

# Recursion breaking

data RecTcChecker Source

initRecTc :: RecTcChecker Source

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