TcType
- 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
- pprUserTypeCtxt :: UserTypeCtxt -> SDoc
- data TcTyVarDetails
- pprTcTyVarDetails :: TcTyVarDetails -> SDoc
- data MetaDetails
- data MetaInfo
- data SkolemInfo
- pprSkolTvBinding :: TcTyVar -> SDoc
- pprSkolInfo :: SkolemInfo -> SDoc
- isImmutableTyVar :: TyVar -> Bool
- isSkolemTyVar :: TcTyVar -> Bool
- isMetaTyVar :: TcTyVar -> Bool
- isMetaTyVarTy :: TcType -> Bool
- isSigTyVar :: Var -> Bool
- isExistentialTyVar :: TcTyVar -> Bool
- isTyConableTyVar :: TcTyVar -> Bool
- metaTvRef :: TyVar -> IORef MetaDetails
- isFlexi :: MetaDetails -> Bool
- isIndirect :: MetaDetails -> Bool
- isUnkSkol :: TyVar -> 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
- isRigidTy :: TcType -> 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
- tyClsNamesOfType :: Type -> NameSet
- tyClsNamesOfDFunHead :: 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
- isRefineableTy :: TcType -> (Bool, Bool)
- isRefineablePred :: TcPredType -> Bool
- 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)
- tidySkolemTyVar :: TidyEnv -> TcTyVar -> (TidyEnv, TcTyVar)
- 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
- 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 TcSigmaType = TcTypeSource
type TcPredType = PredTypeSource
type TcThetaType = ThetaTypeSource
type TcTyVarSet = TyVarSetSource
data UserTypeCtxt Source
data TcTyVarDetails Source
Constructors
SkolemTv SkolemInfo | |
FlatSkol TcType | |
MetaTv MetaInfo (IORef MetaDetails) |
data SkolemInfo Source
Constructors
SigSkol UserTypeCtxt | |
ClsSkol Class | |
InstSkol | |
FamInstSkol | |
PatSkol DataCon (HsMatchContext Name) | |
ArrowSkol | |
IPSkol [IPName Name] | |
RuleSkol RuleName | |
GenSkol TcType | |
RuntimeUnkSkol | |
NoScSkol | |
UnkSkol |
Instances
pprSkolInfo :: SkolemInfo -> SDocSource
isImmutableTyVar :: TyVar -> BoolSource
isSkolemTyVar :: TcTyVar -> BoolSource
isMetaTyVar :: TcTyVar -> BoolSource
isMetaTyVarTy :: TcType -> BoolSource
isSigTyVar :: Var -> BoolSource
metaTvRef :: TyVar -> IORef MetaDetailsSource
isFlexi :: MetaDetails -> BoolSource
isIndirect :: MetaDetails -> BoolSource
isRuntimeUnkSkol :: TyVar -> BoolSource
tcView :: Type -> Maybe TypeSource
Similar to coreView
, but for the type checker, which just looks through synonyms
tcSplitForAllTys :: Type -> ([TyVar], Type)Source
tcSplitPhiTy :: Type -> (ThetaType, Type)Source
tcSplitFunTys :: Type -> ([Type], Type)Source
tcFunArgTy :: Type -> TypeSource
tcFunResultTy :: Type -> TypeSource
tcSplitFunTysN :: TcRhoType -> Arity -> ([TcSigmaType], TcSigmaType)Source
tcSplitTyConApp :: Type -> (TyCon, [Type])Source
tcTyConAppTyCon :: Type -> TyConSource
tcTyConAppArgs :: 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
tcGetTyVar_maybe :: Type -> Maybe TyVarSource
tcGetTyVar :: String -> Type -> TyVarSource
tcDeepSplitSigmaTy_maybe :: TcSigmaType -> Maybe ([TcType], [TyVar], ThetaType, TcSigmaType)Source
tcEqType :: Type -> Type -> BoolSource
Type equality on source types. Does not look through newtypes
or
PredType
s, but it does look through type synonyms.
tcCmpType :: Type -> Type -> OrderingSource
Type ordering on source types. Does not look through newtypes
or
PredType
s, but it does look through type synonyms.
tcCmpTypes :: [Type] -> [Type] -> OrderingSource
isOverloadedTy :: Type -> BoolSource
isDoubleTy :: Type -> BoolSource
isStringTy :: Type -> BoolSource
isIntegerTy :: Type -> BoolSource
isTauTyCon :: TyCon -> BoolSource
tcIsTyVarTy :: Type -> BoolSource
tcIsForAllTy :: Type -> BoolSource
deNoteType :: Type -> TypeSource
getDFunTyKey :: Type -> OccNameSource
getClassPredTys :: PredType -> (Class, [Type])Source
isClassPred :: PredType -> BoolSource
mkClassPred :: Class -> [Type] -> PredTypeSource
isDictLikeTy :: Type -> BoolSource
tcSplitDFunHead :: Type -> (Class, [Type])Source
predTyUnique :: PredType -> UniqueSource
isRefineableTy :: TcType -> (Bool, Bool)Source
Tidying type related things up for printing
tidyOpenType :: TidyEnv -> Type -> (TidyEnv, Type)Source
Grabs the free type variables, tidies them
and then uses tidyType
to work over the type itself
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 -> TidyEnvSource
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
tidyTopType :: Type -> TypeSource
Calls tidyType
on a top-level type (i.e. with an empty tidying environment)
isFFIImportResultTy :: DynFlags -> Type -> BoolSource
isFFIExternalTy :: Type -> BoolSource
isFFIDynArgumentTy :: Type -> BoolSource
isFFIDynResultTy :: Type -> BoolSource
isFFIPrimArgumentTy :: DynFlags -> Type -> BoolSource
isFFIPrimResultTy :: DynFlags -> Type -> BoolSource
isFFILabelTy :: Type -> BoolSource
isFFIDotnetTy :: DynFlags -> Type -> BoolSource
isFFIDotnetObjTy :: Type -> BoolSource
isFunPtrTy :: Type -> BoolSource
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)
mkArrowKinds :: [Kind] -> Kind -> KindSource
Iterated application of mkArrowKind
isLiftedTypeKind :: Kind -> BoolSource
isUnliftedTypeKind :: Kind -> BoolSource
isSubOpenTypeKind :: Kind -> BoolSource
True of any sub-kind of OpenTypeKind (i.e. anything except arrow)
isSubArgTypeKind :: Kind -> BoolSource
True of any sub-kind of ArgTypeKind
splitKindFunTys :: Kind -> ([Kind], Kind)Source
Essentially splitFunTys
on kinds
defaultKind :: Kind -> KindSource
Used when generalising: default kind ? and ?? to *. See Type for more information on what that means
The key representation of types within the compiler
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"
mkForAllTy :: TyVar -> Type -> TypeSource
mkForAllTys :: [TyVar] -> Type -> TypeSource
Wraps foralls over the type using the provided TyVar
s from left to right
mkFunTy :: Type -> Type -> TypeSource
Creates a function type from the given argument and result type
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] -> TypeSource
A key function: builds a TyConApp
or FunTy
as apppropriate to its arguments.
Applies its arguments to the constructor from left to right
applyTy :: Type -> Type -> TypeSource
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] -> TypeSource
This function is interesting because:
- The function may have more for-alls than there are args
- 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 ()
mkTyVarTys :: [TyVar] -> [Type]Source
mkTyConTy :: TyCon -> TypeSource
Create the plain type constructor type which has been applied to no type arguments at all.
Type substitution
The following invariants must hold of a TvSubst
:
- The in-scope set is needed only to guide the generation of fresh uniques
- In particular, the kind of the type variables in the in-scope set is not relevant
- The substition is only applied ONCE! This is because in general such application will not reached a fixed point.
Constructors
TvSubst InScopeSet TvSubstEnv |
Instances
zipOpenTvSubst :: [TyVar] -> [Type] -> TvSubstSource
zipTopTvSubst :: [TyVar] -> [Type] -> TvSubstSource
mkTopTvSubst :: [(TyVar, Type)] -> TvSubstSource
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 -> BoolSource
unionTvSubst :: TvSubst -> TvSubst -> TvSubstSource
setTvSubstEnv :: TvSubst -> TvSubstEnv -> TvSubstSource
extendTvInScope :: TvSubst -> Var -> TvSubstSource
mkTvSubst :: InScopeSet -> TvSubstEnv -> TvSubstSource
zipTyEnv :: [TyVar] -> [Type] -> TvSubstEnvSource
substTyWith :: [TyVar] -> [Type] -> Type -> TypeSource
Type substitution making use of an TvSubst
that
is assumed to be open, see zipOpenTvSubst
substTyVar :: TvSubst -> TyVar -> TypeSource
substTyVars :: TvSubst -> [TyVar] -> [Type]Source
isUnLiftedType :: Type -> BoolSource
See Type for what an unlifted type is
isUnboxedTupleType :: Type -> BoolSource
isPrimitiveType :: Type -> BoolSource
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 -> TyVarSetSource
NB: for type synonyms tyVarsOfType does not expand the synonym
tyVarsOfTypes :: [Type] -> TyVarSetSource
tcTyVarsOfTypes :: [Type] -> TyVarSetSource
exactTyVarsOfTypes :: [TcType] -> TyVarSetSource
pprParendKind :: Kind -> SDocSource
pprParendType :: Type -> SDocSource
pprTypeApp :: NamedThing a => a -> [Type] -> SDocSource
pprThetaArrow :: ThetaType -> SDocSource
pprClassPred :: Class -> [Type] -> SDocSource