ghc-7.10.2: The GHC API

Safe HaskellNone
LanguageHaskell2010

TcType

Contents

Synopsis

Documentation

type TcType = Type

type TcTyVar = TyVar

type TcKind = Kind

type TcCoVar = CoVar

newtype TcLevel

Constructors

TcLevel Int 

data MetaDetails

Constructors

Flexi 
Indirect TcType 

isFskTyVar :: TcTyVar -> Bool

True of FlatSkol skolems only

isFlattenTyVar :: TcTyVar -> Bool

True of both given and wanted flatten-skolems (fak and usk)

mkSigmaTy :: [TyVar] -> [PredType] -> Type -> Type

mkTcReprEqPred :: TcType -> TcType -> Type

Make a representational equality predicate

mkTcEqPredRole :: Role -> TcType -> TcType -> Type

Make an equality predicate at a given role. The role must not be Phantom.

tcView :: Type -> Maybe Type

Similar to coreView, but for the type checker, which just looks through synonyms

repSplitAppTy_maybe :: Type -> Maybe (Type, Type)

Does the AppTy split as in splitAppTy_maybe, but assumes that any Core view stuff is already done

nextRole :: Type -> Role

What is the role assigned to the next parameter of this type? Usually, this will be Nominal, but if the type is a TyConApp, we may be able to do better. The type does *not* have to be well-kinded when applied for this to work!

eqType :: Type -> Type -> Bool

Type equality on source types. Does not look through newtypes or PredTypes, but it does look through type synonyms. Watch out for horrible hack: See Note [Comparison with OpenTypeKind]

eqTypes :: [Type] -> [Type] -> Bool

cmpTypes :: [Type] -> [Type] -> Ordering

isTyVarExposed :: TcTyVar -> TcType -> Bool

Does the given tyvar appear in the given type outside of any non-newtypes? Assume we're looking for a. Says "yes" for a, N a, b a, a b, b (N a). Says "no" for [a], Maybe a, T a, where N is a newtype and T is a datatype.

Finding type instances

tcTyFamInsts :: Type -> [(TyCon, [Type])]

Finds outermost type-family applications occuring in a type, after expanding synonyms.

Finding "exact" (non-dead) type variables

type Kind = Type

The key type representing kinds in the compiler. Invariant: a kind is always in one of these forms:

FunTy k1 k2
TyConApp PrimTyCon [...]
TyVar kv   -- (during inference only)
ForAll ... -- (for top-level coercions)

unliftedTypeKind :: Kind

See Type for details of the distinction between these Kinds

liftedTypeKind :: Kind

See Type for details of the distinction between these Kinds

openTypeKind :: Kind

See Type for details of the distinction between these Kinds

constraintKind :: Kind

See Type for details of the distinction between these Kinds

mkArrowKind :: Kind -> Kind -> Kind

Given two kinds k1 and k2, creates the Kind k1 -> k2

mkArrowKinds :: [Kind] -> Kind -> Kind

Iterated application of mkArrowKind

isUnliftedTypeKind :: Kind -> Bool

See Type for details of the distinction between these Kinds

isSubOpenTypeKind :: Kind -> Bool

True of any sub-kind of OpenTypeKind

splitKindFunTys :: Kind -> ([Kind], Kind)

Essentially splitFunTys on kinds

data Type

The key representation of types within the compiler

Instances

type PredType = Type

A type of the form p of kind Constraint represents a value whose type is the Haskell predicate p, where a predicate is what occurs before the => in a Haskell type.

We use PredType as documentation to mark those types that we guarantee to have this kind.

It can be expanded into its representation, but:

  • The type checker must treat it as opaque
  • The rest of the compiler treats it as transparent

Consider these examples:

f :: (Eq a) => a -> Int
g :: (?x :: Int -> Int) => a -> Int
h :: (r\l) => {r} => {l::Int | r}

Here the Eq a and ?x :: Int -> Int and rl are all called "predicates"

type ThetaType = [PredType]

A collection of PredTypes

mkForAllTys :: [TyVar] -> Type -> Type

Wraps foralls over the type using the provided TyVars from left to right

mkFunTy :: Type -> Type -> Type infixr 3

Creates a function type from the given argument and result type

mkFunTys :: [Type] -> Type -> Type

zipFunTys :: Outputable a => [a] -> Type -> ([(a, Type)], Type)

Splits off argument types from the given type and associating them with the things in the input list from left to right. The final result type is returned, along with the resulting pairs of objects and types, albeit with the list of pairs in reverse order. Panics if there are not enough argument types for the input list.

mkTyConApp :: TyCon -> [Type] -> Type

A key function: builds a TyConApp or FunTy as appropriate to its arguments. Applies its arguments to the constructor from left to right.

mkAppTy :: Type -> Type -> Type

Applies a type to another, as in e.g. k a

mkAppTys :: Type -> [Type] -> Type

applyTy :: Type -> KindOrType -> Type

Instantiate a forall type with one or more type arguments. Used when we have a polymorphic function applied to type args:

f t1 t2

We use applyTys type-of-f [t1,t2] to compute the type of the expression. Panics if no application is possible.

applyTys :: Type -> [KindOrType] -> Type

This function is interesting because:

  1. The function may have more for-alls than there are args
  2. Less obviously, it may have fewer for-alls

For case 2. think of:

applyTys (forall a.a) [forall b.b, Int]

This really can happen, but only (I think) in situations involving undefined. For example: undefined :: forall a. a Term: undefined (forall b. b->b) Int This term should have type (Int -> Int), but notice that there are more type args than foralls in undefineds type.

mkTyConTy :: TyCon -> Type

Create the plain type constructor type which has been applied to no type arguments at all.

mkEqPred :: Type -> Type -> PredType

Creates a type equality predicate

data TvSubst

Type substitution

The following invariants must hold of a TvSubst:

  1. The in-scope set is needed only to guide the generation of fresh uniques
  2. In particular, the kind of the type variables in the in-scope set is not relevant
  3. The substitution is only applied ONCE! This is because in general such application will not reached a fixed point.

type TvSubstEnv = TyVarEnv Type

A substitution of Types for TyVars and Kinds for KindVars

mkOpenTvSubst :: TvSubstEnv -> TvSubst

Generates the in-scope set for the TvSubst from the types in the incoming environment, hence "open"

zipOpenTvSubst :: [TyVar] -> [Type] -> TvSubst

Generates the in-scope set for the TvSubst from the types in the incoming environment, hence "open"

mkTopTvSubst :: [(TyVar, Type)] -> TvSubst

Called when doing top-level substitutions. Here we expect that the free vars of the range of the substitution will be empty.

substTy :: TvSubst -> Type -> Type

Substitute within a Type

substTys :: TvSubst -> [Type] -> [Type]

Substitute within several Types

substTyWith :: [TyVar] -> [Type] -> Type -> Type

Type substitution making use of an TvSubst that is assumed to be open, see zipOpenTvSubst

substTheta :: TvSubst -> ThetaType -> ThetaType

Substitute within a ThetaType

isUnLiftedType :: Type -> Bool

See Type for what an unlifted type is

isPrimitiveType :: Type -> Bool

Returns true of types that are opaque to Haskell.

tyVarsOfType :: Type -> VarSet

NB: for type synonyms tyVarsOfType does not expand the synonym tyVarsOfType returns only the free variables of a type For example, tyVarsOfType (a::k) returns {a}, not including the kind variable {k}