| ghc-6.10.4: The GHC API | Contents | Index

TyCon

Contents

Main TyCon data types
  Constructing TyCons
  Predicates on TyCons
  Extracting information out of TyCons
  Manipulating TyCons
Primitive representations of Types

Synopsis

data TyCon
type FieldLabel = Name

data AlgTyConRhs

= AbstractTyCon

| OpenTyCon {

otArgPoss :: AssocFamilyPermutation

}

| DataTyCon {

data_cons :: [DataCon]
is_enum :: Bool

}

| NewTyCon {

data_con :: DataCon
nt_rhs :: Type
nt_etad_rhs :: ([TyVar], Type)
nt_co :: Maybe TyCon

}

visibleDataCons :: AlgTyConRhs -> [DataCon]

data TyConParent

= NoParentTyCon
| ClassTyCon Class
| FamilyTyCon TyCon [Type] TyCon

data SynTyConRhs

= OpenSynTyCon Kind AssocFamilyPermutation
| SynonymTyCon Type

type AssocFamilyPermutation = Maybe [Int]
mkAlgTyCon :: Name -> Kind -> [TyVar] -> [PredType] -> AlgTyConRhs -> [Id] -> TyConParent -> RecFlag -> Bool -> Bool -> TyCon
mkClassTyCon :: Name -> Kind -> [TyVar] -> AlgTyConRhs -> Class -> RecFlag -> TyCon
mkFunTyCon :: Name -> Kind -> TyCon
mkPrimTyCon :: Name -> Kind -> Arity -> PrimRep -> TyCon
mkVoidPrimTyCon :: Name -> Kind -> Arity -> TyCon
mkLiftedPrimTyCon :: Name -> Kind -> Arity -> PrimRep -> TyCon
mkTupleTyCon :: Name -> Kind -> Arity -> [TyVar] -> DataCon -> Boxity -> Bool -> TyCon
mkSynTyCon :: Name -> Kind -> [TyVar] -> SynTyConRhs -> TyConParent -> TyCon
mkSuperKindTyCon :: Name -> TyCon
mkCoercionTyCon :: Name -> Arity -> ([Type] -> (Type, Type)) -> TyCon
mkForeignTyCon :: Name -> Maybe FastString -> Kind -> Arity -> TyCon
isAlgTyCon :: TyCon -> Bool
isClassTyCon :: TyCon -> Bool
isFamInstTyCon :: TyCon -> Bool
isFunTyCon :: TyCon -> Bool
isPrimTyCon :: TyCon -> Bool
isTupleTyCon :: TyCon -> Bool
isUnboxedTupleTyCon :: TyCon -> Bool
isBoxedTupleTyCon :: TyCon -> Bool
isSynTyCon :: TyCon -> Bool
isClosedSynTyCon :: TyCon -> Bool
isOpenSynTyCon :: TyCon -> Bool
isSuperKindTyCon :: TyCon -> Bool
isCoercionTyCon :: TyCon -> Bool
isCoercionTyCon_maybe :: TyCon -> Maybe (Arity, [Type] -> (Type, Type))
isForeignTyCon :: TyCon -> Bool
isDataTyCon :: TyCon -> Bool
isProductTyCon :: TyCon -> Bool
isEnumerationTyCon :: TyCon -> Bool
isNewTyCon :: TyCon -> Bool
isAbstractTyCon :: TyCon -> Bool
isOpenTyCon :: TyCon -> Bool
isUnLiftedTyCon :: TyCon -> Bool
isGadtSyntaxTyCon :: TyCon -> Bool
isTyConAssoc :: TyCon -> Bool
isRecursiveTyCon :: TyCon -> Bool
isHiBootTyCon :: TyCon -> Bool
isImplicitTyCon :: TyCon -> Bool
tyConHasGenerics :: TyCon -> Bool
tyConName :: TyCon -> Name
tyConKind :: TyCon -> Kind
tyConUnique :: TyCon -> Unique
tyConTyVars :: TyCon -> [TyVar]
tyConDataCons :: TyCon -> [DataCon]
tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
tyConSingleDataCon_maybe :: TyCon -> Maybe DataCon
tyConFamilySize :: TyCon -> Int
tyConSelIds :: TyCon -> [Id]
tyConStupidTheta :: TyCon -> [PredType]
tyConArity :: TyCon -> Arity
tyConClass_maybe :: TyCon -> Maybe Class
tyConFamInst_maybe :: TyCon -> Maybe (TyCon, [Type])
tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon
synTyConDefn :: TyCon -> ([TyVar], Type)
synTyConRhs :: TyCon -> SynTyConRhs
synTyConType :: TyCon -> Type
synTyConResKind :: TyCon -> Kind
tyConExtName :: TyCon -> Maybe FastString
algTyConRhs :: TyCon -> AlgTyConRhs
newTyConRhs :: TyCon -> ([TyVar], Type)
newTyConEtadRhs :: TyCon -> ([TyVar], Type)
unwrapNewTyCon_maybe :: TyCon -> Maybe ([TyVar], Type, Maybe TyCon)
assocTyConArgPoss_maybe :: TyCon -> Maybe [Int]
tupleTyConBoxity :: TyCon -> Boxity
tcExpandTyCon_maybe :: TyCon -> [Type] -> Maybe ([(TyVar, Type)], Type, [Type])
coreExpandTyCon_maybe :: TyCon -> [Type] -> Maybe ([(TyVar, Type)], Type, [Type])
makeTyConAbstract :: TyCon -> TyCon
newTyConCo_maybe :: TyCon -> Maybe TyCon
setTyConArgPoss :: [TyVar] -> TyCon -> TyCon

data PrimRep

= VoidRep
| PtrRep
| IntRep
| WordRep
| Int64Rep
| Word64Rep
| AddrRep
| FloatRep
| DoubleRep

tyConPrimRep :: TyCon -> PrimRep
primRepSizeW :: PrimRep -> Int

Main TyCon data types
data TyCon

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

5) Type coercions! This is because we represent a coercion from `t1` to `t2` as a `Type`, where that type has kind `t1 ~ t2`. See Coercion for more on this

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

Instances

Eq TyCon
Ord TyCon
Outputable TyCon
Uniquable TyCon
NamedThing TyCon

type FieldLabel = Name
Names of the fields in an algebraic record type
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.

OpenTyCon

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 T a :: *

Or an assoicated data type declaration, within a class declaration:

     class C a b where
       data T b :: *

otArgPoss :: AssocFamilyPermutation |

DataTyCon | Information about those `TyCon`s derived from a `data` declaration. This includes data types with no constructors at all.

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
is_enum :: Bool | Cached value: is this an enumeration type? (See `isEnumerationTyCon`)

NewTyCon | Information about those `TyCon`s derived from a `newtype` declaration

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 :: Maybe TyCon | A `TyCon` (which is always a `CoercionTyCon`) that can have a Coercion extracted from it to create the `newtype` from the representation `Type`. This field is optional for non-recursive `newtype`s only.

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!

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. We use `TyConParent` for both algebraic and synonym types, but the variant `ClassTyCon` will only be used by algebraic `TyCon`s.

data TyConParent

Constructors

NoParentTyCon | An ordinary type constructor has no parent.
ClassTyCon Class | Type constructors representing a class dictionary.
FamilyTyCon TyCon [Type] TyCon | Type constructors representing an instance of a type 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 `CoercionTyCon` identifying the representation type with the type instance family

data SynTyConRhs

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

OpenSynTyCon Kind AssocFamilyPermutation |
SynonymTyCon Type | The synonym mentions head type variables. It acts as a template for the expansion when the `TyCon` is applied to some types.

type AssocFamilyPermutation = Maybe [Int]
Constructing TyCons
mkAlgTyCon

:: Name |
-> Kind | Kind of the resulting `TyCon`
-> [TyVar] | `TyVar`s scoped over: see `tyConTyVars`. Arity is inferred from the length of this list
-> [PredType] | Stupid theta: see `algTcStupidTheta`
-> AlgTyConRhs | Information about dat aconstructors
-> [Id] | Selector `Id`s
-> TyConParent |
-> RecFlag | Is the `TyCon` recursive?
-> Bool | Does it have generic functions? See `hasGenerics`
-> 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] -> AlgTyConRhs -> Class -> RecFlag -> TyCon
Simpler specialization of `mkAlgTyCon` for classes
mkFunTyCon :: Name -> Kind -> TyCon
Given the name of the function type constructor and it's kind, create the corresponding `TyCon`. It is reccomended to use TypeRep.funTyCon if you want this functionality
mkPrimTyCon :: Name -> Kind -> Arity -> PrimRep -> TyCon
Create an unlifted primitive `TyCon`, such as `Int#`
mkVoidPrimTyCon :: Name -> Kind -> Arity -> TyCon
Create the special void `TyCon` which is unlifted and has `VoidRep`
mkLiftedPrimTyCon :: Name -> Kind -> Arity -> PrimRep -> TyCon
Create a lifted primitive `TyCon` such as `RealWorld`
mkTupleTyCon

:: Name |
-> Kind | Kind of the resulting `TyCon`
-> Arity | Arity of the tuple
-> [TyVar] | `TyVar`s scoped over: see `tyConTyVars`
-> DataCon |
-> Boxity | Whether the tuple is boxed or unboxed
-> Bool | Does it have generic functions? See `hasGenerics`
-> TyCon |
Foreign-imported (.NET) type constructors are represented as primitive, but lifted, TyCons for now. They are lifted because the Haskell type `T` representing the (foreign) .NET type `T` is actually implemented (in ILX) as a `thunkT`

mkSynTyCon :: Name -> Kind -> [TyVar] -> SynTyConRhs -> TyConParent -> TyCon
Create a type synonym `TyCon`
mkSuperKindTyCon :: Name -> TyCon
Create a super-kind `TyCon`
mkCoercionTyCon :: Name -> Arity -> ([Type] -> (Type, Type)) -> TyCon
Create a coercion `TyCon`
mkForeignTyCon

:: Name |
-> Maybe FastString | Name of the foreign imported thing, maybe
-> Kind |
-> Arity |
-> TyCon |

Predicates on TyCons
isAlgTyCon :: TyCon -> Bool
Returns `True` if the supplied `TyCon` resulted from either 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 family instance, be that for a synonym or an algebraic family instance?
isFunTyCon :: TyCon -> Bool
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`, becuase 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?
isSynTyCon :: TyCon -> Bool
A product `TyCon` must both: 1. Have one constructor 2. Not be existential However other than this there are few restrictions: they may be `data` or `newtype` `TyCon`s of any boxity and may even be recursive. Is this a `TyCon` representing a type synonym (`type`)?
isClosedSynTyCon :: TyCon -> Bool
Is this a synonym `TyCon` that can have no further instances appear?
isOpenSynTyCon :: TyCon -> Bool
Is this a synonym `TyCon` that can have may have further instances appear?
isSuperKindTyCon :: TyCon -> Bool
Is this a super-kind `TyCon`?
isCoercionTyCon :: TyCon -> Bool
Is this a `TyCon` that represents a coercion?
isCoercionTyCon_maybe :: TyCon -> Maybe (Arity, [Type] -> (Type, Type))
Attempt to pull a `TyCon` apart into the arity and `coKindFun` of a coercion `TyCon`. Returns `Nothing` if the `TyCon` is not of the appropriate kind
isForeignTyCon :: TyCon -> Bool
Is this the `TyCon` of a foreign-imported type constructor?
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 and type family `TyCon`s. But it is not guarenteed 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
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)
isOpenTyCon :: TyCon -> Bool
Is this a `TyCon`, synonym or otherwise, that may have further instances appear?
isUnLiftedTyCon :: TyCon -> Bool
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
Is this an algebraic `TyCon` declared with the GADT syntax?
isTyConAssoc :: TyCon -> Bool
Are we able to extract informationa `TyVar` to class argument list mappping from a given `TyCon`?
isRecursiveTyCon :: TyCon -> Bool
Is this a recursive `TyCon`?
isHiBootTyCon :: TyCon -> Bool
Did this `TyCon` originate from type-checking a .h*-boot file?
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).

tyConHasGenerics :: TyCon -> Bool
Does this `TyCon` have any generic to/from functions available? See also `hasGenerics`
Extracting information out of TyCons
tyConName :: TyCon -> Name
tyConKind :: TyCon -> Kind
tyConUnique :: TyCon -> Unique
tyConTyVars :: TyCon -> [TyVar]
tyConDataCons :: TyCon -> [DataCon]
As `tyConDataCons_maybe`, but returns the empty list of constructors if no constructors could be found
tyConDataCons_maybe :: TyCon -> Maybe [DataCon]
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
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
tyConFamilySize :: TyCon -> Int
Determine the number of value constructors a `TyCon` has. Panics if the `TyCon` is not algebraic or a tuple
tyConSelIds :: TyCon -> [Id]
Extract the record selector `Id`s from an algebraic `TyCon` and returns the empty list otherwise
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 ...`
tyConArity :: TyCon -> Arity
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 family instance, return the family in question and the instance types. Otherwise, return `Nothing`
tyConFamilyCoercion_maybe :: TyCon -> Maybe TyCon
If this `TyCon` is that of a family instance, return a `TyCon` which represents a coercion identifying the representation type with the type instance family. Otherwise, return `Nothing`
synTyConDefn :: TyCon -> ([TyVar], Type)
Extract the `TyVar`s bound by a type synonym and the corresponding (unsubstituted) right hand side. If the given `TyCon` is not a type synonym, panics
synTyConRhs :: TyCon -> SynTyConRhs
Extract the information pertaining to the right hand side of a type synonym (`type`) declaration. Panics if the given `TyCon` is not a type synonym
synTyConType :: TyCon -> Type
Find the expansion of the type synonym represented by the given `TyCon`. The free variables of this type will typically include those `TyVar`s bound by the `TyCon`. Panics if the `TyCon` is not that of a type synonym
synTyConResKind :: TyCon -> Kind
Find the `Kind` of an open type synonym. Panics if the `TyCon` is not an open type synonym
tyConExtName :: TyCon -> Maybe FastString
`Just e` for foreign-imported types, holds the name of the imported thing
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)
Extract the bound type variables and type expansion of a type synonym `TyCon`. Panics if the `TyCon` is not a synonym
newTyConEtadRhs :: TyCon -> ([TyVar], Type)
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, Maybe TyCon)
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.
assocTyConArgPoss_maybe :: TyCon -> Maybe [Int]
Extract the mapping from `TyVar` indexes to indexes in the corresponding family argument lists form an open `TyCon` of any sort, if the given `TyCon` is indeed such a beast and that information is available
tupleTyConBoxity :: TyCon -> Boxity
Extract the boxity of the given `TyCon`, if it is a `TupleTyCon`. Panics otherwise
Manipulating TyCons
tcExpandTyCon_maybe

:: TyCon |
-> [Type] | Arguments to `TyCon`
-> Maybe ([(TyVar, Type)], Type, [Type]) | Returns a `TyVar` substitution, the body type of the synonym (not yet substituted) and any arguments remaining from the application
Used to create the view the typechecker has on `TyCon`s. We expand (closed) synonyms only, cf. `coreExpandTyCon_maybe` Used to create the view Core has on `TyCon`s. We expand not only closed synonyms like `tcExpandTyCon_maybe`, but also non-recursive `newtype`s

coreExpandTyCon_maybe

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

makeTyConAbstract :: TyCon -> TyCon
Make an algebraic `TyCon` abstract. Panics if the supplied `TyCon` is not algebraic
newTyConCo_maybe :: TyCon -> Maybe TyCon
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`
setTyConArgPoss :: [TyVar] -> TyCon -> TyCon
Set the AssocFamilyPermutation structure in an associated data or type synonym. The [TyVar] are the class type variables. Remember, the tyvars of an associated data/type are a subset of the class tyvars; except that an associated data type can have extra type variables at the end (see Note [Avoid name clashes for associated data types] in TcHsType)
Primitive representations of Types
data PrimRep

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 |

Instances

Eq PrimRep
Show PrimRep
Outputable PrimRep

tyConPrimRep :: TyCon -> PrimRep
Find the primitive representation of a `TyCon`
primRepSizeW :: PrimRep -> Int
Find the size of a `PrimRep`, in words
Produced by Haddock version 2.4.2