Safe Haskell  None 

Language  Haskell2010 
 data TyCon
 type FieldLabel = Name
 data AlgTyConRhs
 = AbstractTyCon Bool
  DataFamilyTyCon
  DataTyCon { }
  NewTyCon {
 data_con :: DataCon
 nt_rhs :: Type
 nt_etad_rhs :: ([TyVar], Type)
 nt_co :: CoAxiom Unbranched
 visibleDataCons :: AlgTyConRhs > [DataCon]
 data TyConParent
 isNoParent :: TyConParent > Bool
 data FamTyConFlav
 data Role
 mkAlgTyCon :: Name > Kind > [TyVar] > [Role] > Maybe CType > [PredType] > AlgTyConRhs > TyConParent > RecFlag > Bool > Maybe TyCon > TyCon
 mkClassTyCon :: Name > Kind > [TyVar] > [Role] > AlgTyConRhs > Class > RecFlag > TyCon
 mkFunTyCon :: Name > Kind > TyCon
 mkPrimTyCon :: Name > Kind > [Role] > PrimRep > TyCon
 mkKindTyCon :: Name > Kind > TyCon
 mkLiftedPrimTyCon :: Name > Kind > [Role] > PrimRep > TyCon
 mkTupleTyCon :: Name > Kind > Arity > [TyVar] > DataCon > TupleSort > Maybe TyCon > TyCon
 mkSynonymTyCon :: Name > Kind > [TyVar] > [Role] > Type > TyCon
 mkFamilyTyCon :: Name > Kind > [TyVar] > FamTyConFlav > TyConParent > TyCon
 mkPromotedDataCon :: DataCon > Name > Unique > Kind > [Role] > TyCon
 mkPromotedTyCon :: TyCon > Kind > 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
 isTypeSynonymTyCon :: TyCon > Bool
 isDecomposableTyCon :: TyCon > Bool
 isPromotedDataCon :: TyCon > Bool
 isPromotedTyCon :: TyCon > Bool
 isPromotedDataCon_maybe :: TyCon > Maybe DataCon
 isPromotedTyCon_maybe :: TyCon > Maybe TyCon
 promotableTyCon_maybe :: TyCon > Maybe TyCon
 promoteTyCon :: TyCon > TyCon
 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
 isClosedSynFamilyTyCon_maybe :: TyCon > Maybe (CoAxiom Branched)
 isBuiltInSynFamTyCon_maybe :: TyCon > Maybe BuiltInSynFamily
 isUnLiftedTyCon :: TyCon > Bool
 isGadtSyntaxTyCon :: TyCon > Bool
 isDistinctTyCon :: TyCon > Bool
 isDistinctAlgRhs :: AlgTyConRhs > Bool
 isTyConAssoc :: TyCon > Bool
 tyConAssoc_maybe :: TyCon > Maybe Class
 isRecursiveTyCon :: TyCon > Bool
 isImplicitTyCon :: 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
 tyConSingleAlgDataCon_maybe :: TyCon > Maybe DataCon
 tyConFamilySize :: TyCon > Int
 tyConStupidTheta :: TyCon > [PredType]
 tyConArity :: TyCon > Arity
 tyConRoles :: TyCon > [Role]
 tyConParent :: TyCon > TyConParent
 tyConTuple_maybe :: TyCon > Maybe TupleSort
 tyConClass_maybe :: TyCon > Maybe Class
 tyConFamInst_maybe :: TyCon > Maybe (TyCon, [Type])
 tyConFamInstSig_maybe :: TyCon > Maybe (TyCon, [Type], CoAxiom Unbranched)
 tyConFamilyCoercion_maybe :: TyCon > Maybe (CoAxiom Unbranched)
 synTyConDefn_maybe :: TyCon > Maybe ([TyVar], Type)
 synTyConRhs_maybe :: TyCon > Maybe Type
 famTyConFlav_maybe :: TyCon > Maybe FamTyConFlav
 algTyConRhs :: TyCon > AlgTyConRhs
 newTyConRhs :: TyCon > ([TyVar], Type)
 newTyConEtadArity :: TyCon > Int
 newTyConEtadRhs :: TyCon > ([TyVar], Type)
 unwrapNewTyCon_maybe :: TyCon > Maybe ([TyVar], Type, CoAxiom Unbranched)
 unwrapNewTyConEtad_maybe :: TyCon > Maybe ([TyVar], Type, CoAxiom Unbranched)
 tupleTyConBoxity :: TyCon > Boxity
 tupleTyConSort :: TyCon > TupleSort
 tupleTyConArity :: TyCon > Arity
 tcExpandTyCon_maybe :: TyCon > [tyco] > Maybe ([(TyVar, tyco)], Type, [tyco])
 coreExpandTyCon_maybe :: TyCon > [tyco] > Maybe ([(TyVar, tyco)], Type, [tyco])
 makeTyConAbstract :: TyCon > TyCon
 newTyConCo :: TyCon > CoAxiom Unbranched
 newTyConCo_maybe :: TyCon > Maybe (CoAxiom Unbranched)
 pprPromotionQuote :: TyCon > SDoc
 data PrimRep
 data PrimElemRep
 tyConPrimRep :: TyCon > PrimRep
 isVoidRep :: PrimRep > Bool
 isGcPtrRep :: PrimRep > Bool
 primRepSizeW :: DynFlags > PrimRep > Int
 primElemRepSizeB :: PrimElemRep > Int
 data RecTcChecker
 initRecTc :: RecTcChecker
 checkRecTc :: RecTcChecker > TyCon > Maybe RecTcChecker
Main TyCon data types
TyCons represent type constructors. Type constructors are introduced by things such as:
1) Data declarations: data Foo = ...
creates the Foo
type constructor of
kind *
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.
type FieldLabel = Name Source
Names of the fields in an algebraic record type
data AlgTyConRhs Source
Represents righthandsides of TyCon
s for algebraic types
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. 
DataFamilyTyCon  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 associated data type declaration, within a class declaration: class C a b where data T b :: * 
DataTyCon  Information about those 
NewTyCon  Information about those 

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. We use TyConParent
for both algebraic and synonym
types, but the variant ClassTyCon
will only be used by algebraic TyCon
s.
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 TyConParent Source
NoParentTyCon  An ordinary type constructor has no parent. 
ClassTyCon Class  Type constructors representing a class dictionary. See Note [ATyCon for classes] in TypeRep 
AssocFamilyTyCon Class  An *associated* type of a class. 
FamInstTyCon (CoAxiom Unbranched) TyCon [Type]  Type constructors representing an instance of a *data* family. Parameters: 1) The type family in question 2) Instance types; free variables are the 3) A 
isNoParent :: TyConParent > Bool Source
data FamTyConFlav Source
Information pertaining to the expansion of a type synonym (type
)
OpenSynFamilyTyCon  An open type synonym family e.g. 
ClosedSynFamilyTyCon (CoAxiom Branched)  A closed type synonym family e.g.

AbstractClosedSynFamilyTyCon  A closed type synonym family declared in an hsboot file with type family F a where .. 
BuiltInSynFamTyCon BuiltInSynFamily  Builtin type family used by the TypeNats solver 
Constructing TyCons
:: Name  
> Kind  Kind of the resulting 
> [TyVar] 

> [Role]  The roles for each TyVar 
> Maybe CType  The C type this type corresponds to when using the CAPI FFI 
> [PredType]  Stupid theta: see 
> AlgTyConRhs  Information about dat aconstructors 
> TyConParent  
> RecFlag  Is the 
> Bool  Was the 
> Maybe TyCon  Promoted version 
> 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 > TyCon Source
Simpler specialization of mkAlgTyCon
for classes
mkFunTyCon :: Name > Kind > TyCon Source
mkPrimTyCon :: Name > Kind > [Role] > PrimRep > TyCon Source
Create an unlifted primitive TyCon
, such as Int#
mkKindTyCon :: Name > Kind > TyCon Source
Kind constructors
mkLiftedPrimTyCon :: Name > Kind > [Role] > PrimRep > TyCon Source
Create a lifted primitive TyCon
such as RealWorld
mkSynonymTyCon :: Name > Kind > [TyVar] > [Role] > Type > TyCon Source
Create a type synonym TyCon
mkFamilyTyCon :: Name > Kind > [TyVar] > FamTyConFlav > TyConParent > TyCon Source
Create a type family TyCon
mkPromotedDataCon :: DataCon > Name > Unique > 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 prettyprint
the TyCon we add a quote; see the Outputable TyCon instance
mkPromotedTyCon :: TyCon > Kind > TyCon Source
Create a promoted type constructor TyCon
Somewhat dodgily, we give it the same Name
as the type constructor itself
Predicates on TyCons
isAlgTyCon :: TyCon > Bool Source
Returns True
if the supplied TyCon
resulted from either 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
)?
isDecomposableTyCon :: TyCon > Bool Source
isPromotedDataCon :: TyCon > Bool Source
Is this a PromotedDataCon?
isPromotedTyCon :: TyCon > Bool Source
Is this a PromotedTyCon?
isPromotedDataCon_maybe :: TyCon > Maybe DataCon Source
Retrieves the promoted DataCon if this is a PromotedDataCon;
isPromotedTyCon_maybe :: TyCon > Maybe TyCon Source
Retrieves the promoted TyCon if this is a PromotedTyCon;
promoteTyCon :: TyCon > TyCon Source
isDataTyCon :: TyCon > Bool Source
Returns True
for data types that are definitely represented by
heapallocated constructors. These are scrutinised by Corelevel
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
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
isUnLiftedTyCon :: TyCon > Bool Source
isGadtSyntaxTyCon :: TyCon > Bool Source
Is this an algebraic TyCon
declared with the GADT syntax?
isDistinctTyCon :: TyCon > Bool Source
isDistinctTyCon
is true of TyCon
s that are equal only to
themselves, even via coercions (except for unsafeCoerce).
This excludes newtypes, type functions, type synonyms.
It relates directly to the FC consistency story:
If the axioms are consistent,
and co : S tys ~ T tys, and S,T are "distinct" TyCons,
then S=T.
Cf Note [Pruning dead case alternatives] in Unify
isTyConAssoc :: TyCon > Bool Source
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 reconstructed 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).
Extracting information out of TyCons
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:
 The
algTcStupidTheta
 The cached types in algTyConRhs.NewTyCon
 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
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
tyConFamilySize :: TyCon > Int Source
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
tyConParent :: TyCon > TyConParent 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
tyConFamInst_maybe :: TyCon > Maybe (TyCon, [Type]) Source
If this TyCon
is that of a family instance, return the family in question
and the instance types. Otherwise, return Nothing
tyConFamInstSig_maybe :: TyCon > Maybe (TyCon, [Type], CoAxiom Unbranched) Source
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)
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
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 etacontracted.
newTyConEtadRhs :: TyCon > ([TyVar], Type) Source
unwrapNewTyCon_maybe :: TyCon > Maybe ([TyVar], Type, CoAxiom Unbranched) Source
unwrapNewTyConEtad_maybe :: TyCon > Maybe ([TyVar], Type, CoAxiom Unbranched) Source
tupleTyConBoxity :: TyCon > Boxity Source
Extract the boxity of the given TyCon
, if it is a TupleTyCon
.
Panics otherwise
tupleTyConSort :: TyCon > TupleSort Source
tupleTyConArity :: TyCon > Arity Source
Extract the arity of the given TyCon
, if it is a TupleTyCon
.
Panics otherwise
Manipulating TyCons
:: TyCon  
> [tyco]  Arguments to 
> Maybe ([(TyVar, tyco)], Type, [tyco])  Returns a 
Used to create the view Core has on TyCon
s. We expand
not only closed synonyms like tcExpandTyCon_maybe
,
but also nonrecursive newtype
s
Used to create the view the typechecker has on TyCon
s.
We expand (closed) synonyms only, cf. coreExpandTyCon_maybe
:: TyCon  
> [tyco]  Arguments to 
> Maybe ([(TyVar, tyco)], Type, [tyco])  Returns a 
Used to create the view the typechecker has on TyCon
s.
We expand (closed) synonyms only, cf. coreExpandTyCon_maybe
makeTyConAbstract :: TyCon > TyCon Source
newTyConCo :: TyCon > CoAxiom Unbranched Source
newTyConCo_maybe :: TyCon > Maybe (CoAxiom Unbranched) Source
pprPromotionQuote :: TyCon > SDoc Source
Primitive representations of Types
A PrimRep
is an abstraction of a type. It contains information that
the code generator needs in order to pass arguments, return results,
and store values of this type.
data PrimElemRep Source
tyConPrimRep :: TyCon > PrimRep Source
Find the primitive representation of a TyCon
isGcPtrRep :: PrimRep > Bool Source
primElemRepSizeB :: PrimElemRep > Int Source
Recursion breaking
data RecTcChecker Source
checkRecTc :: RecTcChecker > TyCon > Maybe RecTcChecker Source