ghc-7.0.3: The GHC API

TcType

Contents

- Tidying type related things up for printing

Synopsis

- type TcType = Type
- type TcSigmaType = TcType
- type TcRhoType = TcType
- type TcTauType = TcType
- type TcPredType = PredType
- type TcThetaType = ThetaType
- type TcTyVar = TyVar
- type TcTyVarSet = TyVarSet
- type TcKind = Kind
- type TcCoVar = CoVar
- data UserTypeCtxt
  - = FunSigCtxt Name
  - | ExprSigCtxt
  - | ConArgCtxt Name
  - | TySynCtxt Name
  - | GenPatCtxt
  - | LamPatSigCtxt
  - | BindPatSigCtxt
  - | ResSigCtxt
  - | ForSigCtxt Name
  - | DefaultDeclCtxt
  - | SpecInstCtxt
  - | ThBrackCtxt
  - | GenSigCtxt
- pprUserTypeCtxt :: UserTypeCtxt -> SDoc
- data TcTyVarDetails
  - = SkolemTv Bool
  - | RuntimeUnk
  - | FlatSkol TcType
  - | MetaTv MetaInfo (IORef MetaDetails)
- pprTcTyVarDetails :: TcTyVarDetails -> SDoc
- vanillaSkolemTv :: TcTyVarDetails
- superSkolemTv :: TcTyVarDetails
- data MetaDetails
  - = Flexi
  - | Indirect TcType
- data MetaInfo
  - = TauTv
  - | SigTv Name
  - | TcsTv
- isImmutableTyVar :: TyVar -> Bool
- isSkolemTyVar :: TcTyVar -> Bool
- isMetaTyVar :: TcTyVar -> Bool
- isMetaTyVarTy :: TcType -> Bool
- isSigTyVar :: Var -> Bool
- isOverlappableTyVar :: TcTyVar -> Bool
- isTyConableTyVar :: TcTyVar -> Bool
- metaTvRef :: TyVar -> IORef MetaDetails
- isFlexi :: MetaDetails -> Bool
- isIndirect :: MetaDetails -> Bool
- isRuntimeUnkSkol :: TyVar -> Bool
- mkPhiTy :: [PredType] -> Type -> Type
- mkSigmaTy :: [TyVar] -> [PredType] -> Type -> Type
- tcView :: Type -> Maybe Type
- tcSplitForAllTys :: Type -> ([TyVar], Type)
- tcSplitPhiTy :: Type -> (ThetaType, Type)
- tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)
- tcSplitFunTy_maybe :: Type -> Maybe (Type, Type)
- tcSplitFunTys :: Type -> ([Type], Type)
- tcFunArgTy :: Type -> Type
- tcFunResultTy :: Type -> Type
- tcSplitFunTysN :: TcRhoType -> Arity -> ([TcSigmaType], TcSigmaType)
- tcSplitTyConApp :: Type -> (TyCon, [Type])
- tcSplitTyConApp_maybe :: Type -> Maybe (TyCon, [Type])
- tcTyConAppTyCon :: Type -> TyCon
- tcTyConAppArgs :: Type -> [Type]
- tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)
- tcSplitAppTy :: Type -> (Type, Type)
- tcSplitAppTys :: Type -> (Type, [Type])
- repSplitAppTy_maybe :: Type -> Maybe (Type, Type)
- tcInstHeadTyNotSynonym :: Type -> Bool
- tcInstHeadTyAppAllTyVars :: Type -> Bool
- tcGetTyVar_maybe :: Type -> Maybe TyVar
- tcGetTyVar :: String -> Type -> TyVar
- tcSplitSigmaTy :: Type -> ([TyVar], ThetaType, Type)
- tcDeepSplitSigmaTy_maybe :: TcSigmaType -> Maybe ([TcType], [TyVar], ThetaType, TcSigmaType)
- tcEqType :: Type -> Type -> Bool
- tcEqTypes :: [Type] -> [Type] -> Bool
- tcEqPred :: PredType -> PredType -> Bool
- tcCmpType :: Type -> Type -> Ordering
- tcCmpTypes :: [Type] -> [Type] -> Ordering
- tcCmpPred :: PredType -> PredType -> Ordering
- tcEqTypeX :: RnEnv2 -> Type -> Type -> Bool
- eqKind :: Kind -> Kind -> Bool
- isSigmaTy :: Type -> Bool
- isOverloadedTy :: Type -> Bool
- isDoubleTy :: Type -> Bool
- isFloatTy :: Type -> Bool
- isIntTy :: Type -> Bool
- isWordTy :: Type -> Bool
- isStringTy :: Type -> Bool
- isIntegerTy :: Type -> Bool
- isBoolTy :: Type -> Bool
- isUnitTy :: Type -> Bool
- isCharTy :: Type -> Bool
- isTauTy :: Type -> Bool
- isTauTyCon :: TyCon -> Bool
- tcIsTyVarTy :: Type -> Bool
- tcIsForAllTy :: Type -> Bool
- isSynFamilyTyConApp :: TcTauType -> Bool
- deNoteType :: Type -> Type
- orphNamesOfType :: Type -> NameSet
- orphNamesOfDFunHead :: Type -> NameSet
- getDFunTyKey :: Type -> OccName
- getClassPredTys_maybe :: PredType -> Maybe (Class, [Type])
- getClassPredTys :: PredType -> (Class, [Type])
- isClassPred :: PredType -> Bool
- isTyVarClassPred :: PredType -> Bool
- isEqPred :: PredType -> Bool
- mkClassPred :: Class -> [Type] -> PredType
- mkIPPred :: IPName Name -> Type -> PredType
- tcSplitPredTy_maybe :: Type -> Maybe PredType
- mkDictTy :: Class -> [Type] -> Type
- evVarPred :: EvVar -> PredType
- isPredTy :: Type -> Bool
- isDictTy :: Type -> Bool
- isDictLikeTy :: Type -> Bool
- tcSplitDFunTy :: Type -> ([TyVar], Class, [Type])
- tcSplitDFunHead :: Type -> (Class, [Type])
- predTyUnique :: PredType -> Unique
- isIPPred :: PredType -> Bool
- mkMinimalBySCs :: [PredType] -> [PredType]
- transSuperClasses :: Class -> [Type] -> [PredType]
- immSuperClasses :: Class -> [Type] -> [PredType]
- tidyType :: TidyEnv -> Type -> Type
- tidyTypes :: TidyEnv -> [Type] -> [Type]
- tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)
- tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])
- tidyTyVarBndr :: TidyEnv -> TyVar -> (TidyEnv, TyVar)
- tidyFreeTyVars :: TidyEnv -> TyVarSet -> TidyEnv
- tidyOpenTyVar :: TidyEnv -> TyVar -> (TidyEnv, TyVar)
- tidyOpenTyVars :: TidyEnv -> [TyVar] -> (TidyEnv, [TyVar])
- tidyTopType :: Type -> Type
- tidyPred :: TidyEnv -> PredType -> PredType
- tidyKind :: TidyEnv -> Kind -> (TidyEnv, Kind)
- isFFIArgumentTy :: DynFlags -> Safety -> Type -> Bool
- isFFIImportResultTy :: DynFlags -> Type -> Bool
- isFFIExportResultTy :: Type -> Bool
- isFFIExternalTy :: Type -> Bool
- isFFIDynArgumentTy :: Type -> Bool
- isFFIDynResultTy :: Type -> Bool
- isFFIPrimArgumentTy :: DynFlags -> Type -> Bool
- isFFIPrimResultTy :: DynFlags -> Type -> Bool
- isFFILabelTy :: Type -> Bool
- isFFIDotnetTy :: DynFlags -> Type -> Bool
- isFFIDotnetObjTy :: Type -> Bool
- isFFITy :: Type -> Bool
- isFunPtrTy :: Type -> Bool
- tcSplitIOType_maybe :: Type -> Maybe (TyCon, Type, CoercionI)
- typeKind :: Type -> Kind
- type Kind = Type
- unliftedTypeKind :: Kind
- liftedTypeKind :: Kind
- argTypeKind :: Kind
- openTypeKind :: Kind
- mkArrowKind :: Kind -> Kind -> Kind
- mkArrowKinds :: [Kind] -> Kind -> Kind
- isLiftedTypeKind :: Kind -> Bool
- isUnliftedTypeKind :: Kind -> Bool
- isSubOpenTypeKind :: Kind -> Bool
- isSubArgTypeKind :: Kind -> Bool
- isSubKind :: Kind -> Kind -> Bool
- splitKindFunTys :: Kind -> ([Kind], Kind)
- defaultKind :: Kind -> Kind
- kindVarRef :: KindVar -> IORef MetaDetails
- mkKindVar :: Unique -> IORef MetaDetails -> KindVar
- data Type
- data PredType
  - = ClassP Class [Type]
  - | IParam (IPName Name) Type
  - | EqPred Type Type
- type ThetaType = [PredType]
- mkForAllTy :: TyVar -> Type -> Type
- mkForAllTys :: [TyVar] -> Type -> Type
- mkFunTy :: Type -> Type -> Type
- mkFunTys :: [Type] -> Type -> Type
- zipFunTys :: Outputable a => [a] -> Type -> ([(a, Type)], Type)
- mkTyConApp :: TyCon -> [Type] -> Type
- mkAppTy :: Type -> Type -> Type
- mkAppTys :: Type -> [Type] -> Type
- applyTy :: Type -> Type -> Type
- applyTys :: Type -> [Type] -> Type
- mkTyVarTy :: TyVar -> Type
- mkTyVarTys :: [TyVar] -> [Type]
- mkTyConTy :: TyCon -> Type
- mkPredTy :: PredType -> Type
- mkPredTys :: ThetaType -> [Type]
- data TvSubst = TvSubst InScopeSet TvSubstEnv
- type TvSubstEnv = TyVarEnv Type
- emptyTvSubst :: TvSubst
- substEqSpec :: TvSubst -> [(TyVar, Type)] -> [(TcType, TcType)]
- mkOpenTvSubst :: TvSubstEnv -> TvSubst
- zipOpenTvSubst :: [TyVar] -> [Type] -> TvSubst
- zipTopTvSubst :: [TyVar] -> [Type] -> TvSubst
- mkTopTvSubst :: [(TyVar, Type)] -> TvSubst
- notElemTvSubst :: TyVar -> TvSubst -> Bool
- unionTvSubst :: TvSubst -> TvSubst -> TvSubst
- getTvSubstEnv :: TvSubst -> TvSubstEnv
- setTvSubstEnv :: TvSubst -> TvSubstEnv -> TvSubst
- getTvInScope :: TvSubst -> InScopeSet
- extendTvInScope :: TvSubst -> Var -> TvSubst
- lookupTyVar :: TvSubst -> TyVar -> Maybe Type
- extendTvSubst :: TvSubst -> TyVar -> Type -> TvSubst
- extendTvSubstList :: TvSubst -> [TyVar] -> [Type] -> TvSubst
- isInScope :: Var -> TvSubst -> Bool
- mkTvSubst :: InScopeSet -> TvSubstEnv -> TvSubst
- zipTyEnv :: [TyVar] -> [Type] -> TvSubstEnv
- substTy :: TvSubst -> Type -> Type
- substTys :: TvSubst -> [Type] -> [Type]
- substTyWith :: [TyVar] -> [Type] -> Type -> Type
- substTheta :: TvSubst -> ThetaType -> ThetaType
- substTyVar :: TvSubst -> TyVar -> Type
- substTyVars :: TvSubst -> [TyVar] -> [Type]
- substTyVarBndr :: TvSubst -> TyVar -> (TvSubst, TyVar)
- isUnLiftedType :: Type -> Bool
- isUnboxedTupleType :: Type -> Bool
- isPrimitiveType :: Type -> Bool
- tyVarsOfType :: Type -> TyVarSet
- tyVarsOfTypes :: [Type] -> TyVarSet
- tyVarsOfPred :: PredType -> TyVarSet
- tyVarsOfTheta :: ThetaType -> TyVarSet
- tcTyVarsOfType :: Type -> TcTyVarSet
- tcTyVarsOfTypes :: [Type] -> TyVarSet
- tcTyVarsOfPred :: PredType -> TyVarSet
- exactTyVarsOfType :: TcType -> TyVarSet
- exactTyVarsOfTypes :: [TcType] -> TyVarSet
- pprKind :: Kind -> SDoc
- pprParendKind :: Kind -> SDoc
- pprType :: Type -> SDoc
- pprParendType :: Type -> SDoc
- pprTypeApp :: NamedThing a => a -> [Type] -> SDoc
- pprTyThingCategory :: TyThing -> SDoc
- pprPred :: PredType -> SDoc
- pprTheta :: ThetaType -> SDoc
- pprThetaArrow :: ThetaType -> SDoc
- pprClassPred :: Class -> [Type] -> SDoc

# Documentation

type TcType = Type Source

type TcSigmaType = TcType Source

type TcRhoType = TcType Source

type TcTauType = TcType Source

type TcPredType = PredType Source

type TcThetaType = ThetaType Source

type TcTyVar = TyVar Source

type TcTyVarSet = TyVarSet Source

type TcKind = Kind Source

type TcCoVar = CoVar Source

data UserTypeCtxt Source

Constructors

FunSigCtxt Name |
ExprSigCtxt |
ConArgCtxt Name |
TySynCtxt Name |
GenPatCtxt |
LamPatSigCtxt |
BindPatSigCtxt |
ResSigCtxt |
ForSigCtxt Name |
DefaultDeclCtxt |
SpecInstCtxt |
ThBrackCtxt |
GenSigCtxt |

pprUserTypeCtxt :: UserTypeCtxt -> SDoc Source

data TcTyVarDetails Source

Constructors

SkolemTv Bool |
RuntimeUnk |
FlatSkol TcType |
MetaTv MetaInfo (IORef MetaDetails) |

pprTcTyVarDetails :: TcTyVarDetails -> SDoc Source

vanillaSkolemTv :: TcTyVarDetails Source

superSkolemTv :: TcTyVarDetails Source

data MetaDetails Source

Constructors

Flexi |
Indirect TcType |

Instances

Outputable MetaDetails |

data MetaInfo Source

Constructors

TauTv |
SigTv Name |
TcsTv |

isImmutableTyVar :: TyVar -> Bool Source

isSkolemTyVar :: TcTyVar -> Bool Source

isMetaTyVar :: TcTyVar -> Bool Source

isMetaTyVarTy :: TcType -> Bool Source

isSigTyVar :: Var -> Bool Source

isOverlappableTyVar :: TcTyVar -> Bool Source

isTyConableTyVar :: TcTyVar -> Bool Source

metaTvRef :: TyVar -> IORef MetaDetails Source

isFlexi :: MetaDetails -> Bool Source

isIndirect :: MetaDetails -> Bool Source

isRuntimeUnkSkol :: TyVar -> Bool Source

mkPhiTy :: [PredType] -> Type -> Type Source

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

tcView :: Type -> Maybe Type Source

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

tcSplitForAllTys :: Type -> ([TyVar], Type)Source

tcSplitPhiTy :: Type -> (ThetaType, Type)Source

tcSplitPredFunTy_maybe :: Type -> Maybe (PredType, Type)Source

tcSplitFunTy_maybe :: Type -> Maybe (Type, Type)Source

tcSplitFunTys :: Type -> ([Type], Type)Source

tcFunArgTy :: Type -> Type Source

tcFunResultTy :: Type -> Type Source

tcSplitFunTysN :: TcRhoType -> Arity -> ([TcSigmaType], TcSigmaType)Source

tcSplitTyConApp :: Type -> (TyCon, [Type])Source

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

tcTyConAppTyCon :: Type -> TyCon Source

tcTyConAppArgs :: Type -> [Type]Source

tcSplitAppTy_maybe :: Type -> Maybe (Type, Type)Source

tcSplitAppTy :: Type -> (Type, Type)Source

tcSplitAppTys :: Type -> (Type, [Type])Source

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

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

tcInstHeadTyNotSynonym :: Type -> Bool Source

tcInstHeadTyAppAllTyVars :: Type -> Bool Source

tcGetTyVar_maybe :: Type -> Maybe TyVar Source

tcGetTyVar :: String -> Type -> TyVar Source

tcSplitSigmaTy :: Type -> ([TyVar], ThetaType, Type)Source

tcDeepSplitSigmaTy_maybe :: TcSigmaType -> Maybe ([TcType], [TyVar], ThetaType, TcSigmaType)Source

tcEqType :: Type -> Type -> Bool Source

Type equality on source types. Does not look through `newtypes` or `PredType`s, but it does look through type synonyms.

tcEqTypes :: [Type] -> [Type] -> Bool Source

tcEqPred :: PredType -> PredType -> Bool Source

tcCmpType :: Type -> Type -> Ordering Source

Type ordering on source types. Does not look through `newtypes` or `PredType`s, but it does look through type synonyms.

tcCmpTypes :: [Type] -> [Type] -> Ordering Source

tcCmpPred :: PredType -> PredType -> Ordering Source

tcEqTypeX :: RnEnv2 -> Type -> Type -> Bool Source

eqKind :: Kind -> Kind -> Bool Source

isSigmaTy :: Type -> Bool Source

isOverloadedTy :: Type -> Bool Source

isDoubleTy :: Type -> Bool Source

isFloatTy :: Type -> Bool Source

isIntTy :: Type -> Bool Source

isWordTy :: Type -> Bool Source

isStringTy :: Type -> Bool Source

isIntegerTy :: Type -> Bool Source

isBoolTy :: Type -> Bool Source

isUnitTy :: Type -> Bool Source

isCharTy :: Type -> Bool Source

isTauTy :: Type -> Bool Source

isTauTyCon :: TyCon -> Bool Source

tcIsTyVarTy :: Type -> Bool Source

tcIsForAllTy :: Type -> Bool Source

isSynFamilyTyConApp :: TcTauType -> Bool Source

deNoteType :: Type -> Type Source

orphNamesOfType :: Type -> NameSet Source

orphNamesOfDFunHead :: Type -> NameSet Source

getDFunTyKey :: Type -> OccName Source

getClassPredTys_maybe :: PredType -> Maybe (Class, [Type])Source

getClassPredTys :: PredType -> (Class, [Type])Source

isClassPred :: PredType -> Bool Source

isTyVarClassPred :: PredType -> Bool Source

isEqPred :: PredType -> Bool Source

mkClassPred :: Class -> [Type] -> PredType Source

mkIPPred :: IPName Name -> Type -> PredType Source

tcSplitPredTy_maybe :: Type -> Maybe PredType Source

mkDictTy :: Class -> [Type] -> Type Source

evVarPred :: EvVar -> PredType Source

isPredTy :: Type -> Bool Source

isDictTy :: Type -> Bool Source

isDictLikeTy :: Type -> Bool Source

tcSplitDFunTy :: Type -> ([TyVar], Class, [Type])Source

tcSplitDFunHead :: Type -> (Class, [Type])Source

predTyUnique :: PredType -> Unique Source

isIPPred :: PredType -> Bool Source

mkMinimalBySCs :: [PredType] -> [PredType]Source

transSuperClasses :: Class -> [Type] -> [PredType]Source

immSuperClasses :: Class -> [Type] -> [PredType]Source

# Tidying type related things up for printing

tidyType :: TidyEnv -> Type -> Type Source

tidyTypes :: TidyEnv -> [Type] -> [Type]Source

tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)Source

Grabs the free type variables, tidies them and then uses `tidyType` to work over the type itself

tidyOpenTypes :: TidyEnv -> [Type] -> (TidyEnv, [Type])Source

tidyTyVarBndr :: TidyEnv -> TyVar -> (TidyEnv, TyVar)Source

This tidies up a type for printing in an error message, or in an interface file.

It doesn't change the uniques at all, just the print names.

tidyFreeTyVars :: TidyEnv -> TyVarSet -> TidyEnv Source

Add the free `TyVar`s to the env in tidy form, so that we can tidy the type they are free in

tidyOpenTyVar :: TidyEnv -> TyVar -> (TidyEnv, TyVar)Source

Treat a new `TyVar` as a binder, and give it a fresh tidy name using the environment if one has not already been allocated. See also `tidyTyVarBndr`

tidyOpenTyVars :: TidyEnv -> [TyVar] -> (TidyEnv, [TyVar])Source

tidyTopType :: Type -> Type Source

Calls `tidyType` on a top-level type (i.e. with an empty tidying environment)

tidyPred :: TidyEnv -> PredType -> PredType Source

tidyKind :: TidyEnv -> Kind -> (TidyEnv, Kind)Source

isFFIArgumentTy :: DynFlags -> Safety -> Type -> Bool Source

isFFIImportResultTy :: DynFlags -> Type -> Bool Source

isFFIExportResultTy :: Type -> Bool Source

isFFIExternalTy :: Type -> Bool Source

isFFIDynArgumentTy :: Type -> Bool Source

isFFIDynResultTy :: Type -> Bool Source

isFFIPrimArgumentTy :: DynFlags -> Type -> Bool Source

isFFIPrimResultTy :: DynFlags -> Type -> Bool Source

isFFILabelTy :: Type -> Bool Source

isFFIDotnetTy :: DynFlags -> Type -> Bool Source

isFFIDotnetObjTy :: Type -> Bool Source

isFFITy :: Type -> Bool Source

isFunPtrTy :: Type -> Bool Source

tcSplitIOType_maybe :: Type -> Maybe (TyCon, Type, CoercionI)Source

typeKind :: Type -> Kind Source

type Kind = Type Source

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 Source

See Type for details of the distinction between these `Kind`s

liftedTypeKind :: Kind Source

argTypeKind :: Kind Source

openTypeKind :: Kind Source

mkArrowKind :: Kind -> Kind -> Kind Source

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

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

Iterated application of `mkArrowKind`

isLiftedTypeKind :: Kind -> Bool Source

isUnliftedTypeKind :: Kind -> Bool Source

isSubOpenTypeKind :: Kind -> Bool Source

True of any sub-kind of OpenTypeKind (i.e. anything except arrow)

isSubArgTypeKind :: Kind -> Bool Source

True of any sub-kind of ArgTypeKind

isSubKind :: Kind -> Kind -> Bool Source

`k1 `isSubKind` k2` checks that `k1` <: `k2`

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

Essentially `splitFunTys` on kinds

defaultKind :: Kind -> Kind Source

Used when generalising: default kind ? and ?? to *. See Type for more information on what that means

kindVarRef :: KindVar -> IORef MetaDetails Source

mkKindVar :: Unique -> IORef MetaDetails -> KindVar Source

data Type Source

The key representation of types within the compiler

Instances

Data Type |
Typeable Type |
Outputable Type |

data PredType Source

A type of the form `PredTy p` represents a value whose type is the Haskell predicate `p`, where a predicate is what occurs before the `=>` in a Haskell type. 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"

Constructors

ClassP Class [Type] | Class predicate e.g. `Eq a`
IParam (IPName Name) Type | Implicit parameter e.g. `?x :: Int`
EqPred Type Type | Equality predicate e.g `ty1 ~ ty2`

Instances

Eq PredType |
Data PredType |
Ord PredType |
Typeable PredType |
Outputable PredType |

type ThetaType = [PredType]Source

A collection of `PredType`s

mkForAllTy :: TyVar -> Type -> Type Source

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

Wraps foralls over the type using the provided `TyVar`s from left to right

mkFunTy :: Type -> Type -> Type Source

Creates a function type from the given argument and result type

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

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

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 Source

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

mkAppTy :: Type -> Type -> Type Source

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

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

applyTy :: Type -> Type -> Type Source

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

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, via dressing up polymorphic types with newtype clothing. Here's an example:

     newtype R = R (forall a. a->a)
     foo = case undefined :: R of
                R f -> f ()

mkTyVarTy :: TyVar -> Type Source

mkTyVarTys :: [TyVar] -> [Type]Source

mkTyConTy :: TyCon -> Type Source

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

mkPredTy :: PredType -> Type Source

mkPredTys :: ThetaType -> [Type]Source

data TvSubst Source

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 substition is only applied ONCE! This is because in general such application will not reached a fixed point.

Constructors

TvSubst InScopeSet TvSubstEnv |

Instances

Outputable TvSubst |

type TvSubstEnv = TyVarEnv Type Source

A substitition of `Type`s for `TyVar`s

emptyTvSubst :: TvSubst Source

substEqSpec :: TvSubst -> [(TyVar, Type)] -> [(TcType, TcType)]Source

mkOpenTvSubst :: TvSubstEnv -> TvSubst Source

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

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

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

zipTopTvSubst :: [TyVar] -> [Type] -> TvSubst Source

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

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

notElemTvSubst :: TyVar -> TvSubst -> Bool Source

unionTvSubst :: TvSubst -> TvSubst -> TvSubst Source

getTvSubstEnv :: TvSubst -> TvSubstEnv Source

setTvSubstEnv :: TvSubst -> TvSubstEnv -> TvSubst Source

getTvInScope :: TvSubst -> InScopeSet Source

extendTvInScope :: TvSubst -> Var -> TvSubst Source

lookupTyVar :: TvSubst -> TyVar -> Maybe Type Source

extendTvSubst :: TvSubst -> TyVar -> Type -> TvSubst Source

extendTvSubstList :: TvSubst -> [TyVar] -> [Type] -> TvSubst Source

isInScope :: Var -> TvSubst -> Bool Source

mkTvSubst :: InScopeSet -> TvSubstEnv -> TvSubst Source

zipTyEnv :: [TyVar] -> [Type] -> TvSubstEnv Source

substTy :: TvSubst -> Type -> Type Source

Substitute within a `Type`

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

Substitute within several `Type`s

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

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

substTheta :: TvSubst -> ThetaType -> ThetaType Source

Substitute within a `ThetaType`

substTyVar :: TvSubst -> TyVar -> Type Source

substTyVars :: TvSubst -> [TyVar] -> [Type]Source

substTyVarBndr :: TvSubst -> TyVar -> (TvSubst, TyVar)Source

isUnLiftedType :: Type -> Bool Source

See Type for what an unlifted type is

isUnboxedTupleType :: Type -> Bool Source

isPrimitiveType :: Type -> Bool Source

Returns true of types that are opaque to Haskell. Most of these are unlifted, but now that we interact with .NET, we may have primtive (foreign-imported) types that are lifted

tyVarsOfType :: Type -> TyVarSet Source

NB: for type synonyms tyVarsOfType does not expand the synonym

tyVarsOfTypes :: [Type] -> TyVarSet Source

tyVarsOfPred :: PredType -> TyVarSet Source

tyVarsOfTheta :: ThetaType -> TyVarSet Source

tcTyVarsOfType :: Type -> TcTyVarSet Source

tcTyVarsOfTypes :: [Type] -> TyVarSet Source

tcTyVarsOfPred :: PredType -> TyVarSet Source

exactTyVarsOfType :: TcType -> TyVarSet Source

exactTyVarsOfTypes :: [TcType] -> TyVarSet Source

pprKind :: Kind -> SDoc Source

pprParendKind :: Kind -> SDoc Source

pprType :: Type -> SDoc Source

pprParendType :: Type -> SDoc Source

pprTypeApp :: NamedThing a => a -> [Type] -> SDoc Source

pprTyThingCategory :: TyThing -> SDoc Source

pprPred :: PredType -> SDoc Source

pprTheta :: ThetaType -> SDoc Source

pprThetaArrow :: ThetaType -> SDoc Source

pprClassPred :: Class -> [Type] -> SDoc Source