GHC.Tc.Utils.TcMType

Monadic type operations

This module contains monadic operations over types that contain mutable type variables.

Documentation

type TcTyVar = Var

Type variable that might be a metavariable

type TcKind = Kind

type TcType = Type

type TcTauType = TcType

type TcThetaType = ThetaType

type TcTyVarSet = TyVarSet

newFlexiTyVar :: Kind -> TcM TcTyVar

newNamedFlexiTyVar :: FastString -> Kind -> TcM TcTyVar

Create a new flexi ty var with a specific name

newFlexiTyVarTy :: Kind -> TcM TcType

newFlexiTyVarTys :: Int -> Kind -> TcM [TcType]

newOpenFlexiTyVar :: TcM TcTyVar

newOpenFlexiTyVarTy :: TcM TcType

Create a tyvar that can be a lifted or unlifted type. Returns alpha :: TYPE kappa, where both alpha and kappa are fresh

newOpenTypeKind :: TcM TcKind

newOpenBoxedTypeKind :: TcM TcKind

newMetaKindVar :: TcM TcKind

newMetaKindVars :: Int -> TcM [TcKind]

newMetaTyVarTyAtLevel :: TcLevel -> TcKind -> TcM TcType

newAnonMetaTyVar :: MetaInfo -> Kind -> TcM TcTyVar

newConcreteTyVar :: HasDebugCallStack => ConcreteTvOrigin -> TcKind -> TcM TcTyVar

Create a new metavariable, of the given kind, which can only be unified with a concrete type.

Invariant: the kind must be concrete, as per Note [ConcreteTv]. This is checked with an assertion.

cloneMetaTyVar :: TcTyVar -> TcM TcTyVar

newCycleBreakerTyVar :: TcKind -> TcM TcTyVar

newMultiplicityVar :: TcM TcType

readMetaTyVar :: TyVar -> TcM MetaDetails

writeMetaTyVar :: TcTyVar -> TcType -> TcM ()

writeMetaTyVarRef :: TcTyVar -> TcRef MetaDetails -> TcType -> TcM ()

newTauTvDetailsAtLevel :: TcLevel -> TcM TcTyVarDetails

newMetaDetails :: MetaInfo -> TcM TcTyVarDetails

newMetaTyVarName :: FastString -> TcM Name

isFilledMetaTyVar_maybe :: TcTyVar -> TcM (Maybe Type)

isFilledMetaTyVar :: TyVar -> TcM Bool

isUnfilledMetaTyVar :: TyVar -> TcM Bool

newEvVar :: TcPredType -> TcRnIf gbl lcl EvVar

newEvVars :: TcThetaType -> TcM [EvVar]

newDict :: Class -> [TcType] -> TcM DictId

newWantedWithLoc :: CtLoc -> PredType -> TcM CtEvidence

Create a new Wanted constraint with the given CtLoc.

newWanted :: CtOrigin -> Maybe TypeOrKind -> PredType -> TcM CtEvidence

Create a new Wanted constraint with the given CtOrigin, and location information taken from the TcM environment.

newWanteds :: CtOrigin -> ThetaType -> TcM [CtEvidence]

Create new Wanted constraints with the given CtOrigin, and location information taken from the TcM environment.

cloneWanted :: Ct -> TcM Ct

cloneWC :: WantedConstraints -> TcM WantedConstraints

cloneWantedCtEv :: CtEvidence -> TcM CtEvidence

emitWanted :: CtOrigin -> TcPredType -> TcM EvTerm

Emits a new Wanted. Deals with both equalities and non-equalities.

emitWantedEq :: CtOrigin -> TypeOrKind -> Role -> TcType -> TcType -> TcM Coercion

Emits a new equality constraint

emitWantedEvVar :: CtOrigin -> TcPredType -> TcM EvVar

Creates a new EvVar and immediately emits it as a Wanted. No equality predicates here.

emitWantedEvVars :: CtOrigin -> [TcPredType] -> TcM [EvVar]

emitWantedEqs :: CtOrigin -> [(TcType, TcType)] -> TcM ()

newTcEvBinds :: TcM EvBindsVar

newNoTcEvBinds :: TcM EvBindsVar

Creates an EvBindsVar incapable of holding any bindings. It still tracks covar usages (see comments on ebv_tcvs in GHC.Tc.Types.Evidence), thus must be made monadically

addTcEvBind :: EvBindsVar -> EvBind -> TcM ()

emitNewExprHole :: RdrName -> Type -> TcM HoleExprRef

Emit a new wanted expression hole

newCoercionHole :: TcPredType -> TcM CoercionHole

fillCoercionHole :: CoercionHole -> Coercion -> TcM ()

Put a value in a coercion hole

isFilledCoercionHole :: CoercionHole -> TcM Bool

Is a coercion hole filled in?

unpackCoercionHole :: CoercionHole -> TcM Coercion

Retrieve the contents of a coercion hole. Panics if the hole is unfilled

unpackCoercionHole_maybe :: CoercionHole -> TcM (Maybe Coercion)

Retrieve the contents of a coercion hole, if it is filled

checkCoercionHole :: CoVar -> Coercion -> TcM Coercion

Check that a coercion is appropriate for filling a hole. (The hole itself is needed only for printing.) Always returns the checked coercion, but this return value is necessary so that the input coercion is forced only when the output is forced.

type ConcreteHole = CoercionHole

A coercion hole used to store evidence for `Concrete#` constraints.

See Note [The Concrete mechanism].

newConcreteHole

Arguments

:: Kind

Kind of the thing we want to ensure is concrete (e.g. runtimeRepTy)

-> Type

Thing we want to ensure is concrete (e.g. some RuntimeRep)

-> TcM (ConcreteHole, TcType)

where to put the evidence, and a metavariable to store the concrete type

Create a new (initially unfilled) coercion hole, to hold evidence for a 'Concrete#' (ty :: ki) constraint.

newImplication :: TcM Implication

Create a new Implication with as many sensible defaults for its fields as possible. Note that the ic_tclvl, ic_binds, and ic_info fields do not have sensible defaults, so they are initialized with lazy thunks that will panic if forced, so one should take care to initialize these fields after creation.

This is monadic to look up the TcLclEnv, which is used to initialize ic_env, and to set the -Winaccessible-code flag. See Note [Avoid -Winaccessible-code when deriving] in GHC.Tc.TyCl.Instance.

newMetaTyVars :: [TyVar] -> TcM (Subst, [TcTyVar])

newMetaTyVarX :: Subst -> TyVar -> TcM (Subst, TcTyVar)

newMetaTyVarsX :: Subst -> [TyVar] -> TcM (Subst, [TcTyVar])

newMetaTyVarTyVarX :: Subst -> TyVar -> TcM (Subst, TcTyVar)

newTyVarTyVar :: Name -> Kind -> TcM TcTyVar

cloneTyVarTyVar :: Name -> Kind -> TcM TcTyVar

newPatSigTyVar :: Name -> Kind -> TcM TcTyVar

newSkolemTyVar :: SkolemInfo -> Name -> Kind -> TcM TcTyVar

newWildCardX :: Subst -> TyVar -> TcM (Subst, TcTyVar)

data ExpType

An expected type to check against during type-checking. See Note [ExpType] in GHC.Tc.Utils.TcMType, where you'll also find manipulators.

Constructors

Check TcType

Infer !InferResult

Instances

Outputable ExpType

Defined in GHC.Tc.Utils.TcType

Methods

ppr :: ExpType -> SDoc

type ExpSigmaType = ExpType

type ExpRhoType = ExpType

mkCheckExpType :: TcType -> ExpType

Make an ExpType suitable for checking.

newInferExpType :: TcM ExpType

newInferExpTypeFRR :: FixedRuntimeRepContext -> TcM ExpTypeFRR

tcInfer :: (ExpSigmaType -> TcM a) -> TcM (a, TcSigmaType)

Infer a type using a fresh ExpType See also Note [ExpType] in GHC.Tc.Utils.TcMType

Use tcInferFRR if you require the type to have a fixed runtime representation.

tcInferFRR :: FixedRuntimeRepContext -> (ExpSigmaTypeFRR -> TcM a) -> TcM (a, TcSigmaTypeFRR)

Like tcInfer, except it ensures that the resulting type has a syntactically fixed RuntimeRep as per Note [Fixed RuntimeRep] in GHC.Tc.Utils.Concrete.

readExpType :: ExpType -> TcM TcType

Extract a type out of an ExpType. Otherwise, panics.

readExpType_maybe :: ExpType -> TcM (Maybe TcType)

Extract a type out of an ExpType, if one exists. But one should always exist. Unless you're quite sure you know what you're doing.

readScaledExpType :: Scaled ExpType -> TcM (Scaled Type)

Same as readExpType, but for Scaled ExpTypes

expTypeToType :: ExpType -> TcM TcType

Extracts the expected type if there is one, or generates a new TauTv if there isn't.

scaledExpTypeToType :: Scaled ExpType -> TcM (Scaled TcType)

checkingExpType_maybe :: ExpType -> Maybe TcType

Returns the expected type when in checking mode.

checkingExpType :: String -> ExpType -> TcType

Returns the expected type when in checking mode. Panics if in inference mode.

inferResultToType :: InferResult -> TcM Type

ensureMonoType :: TcType -> TcM ()

promoteTcType :: TcLevel -> TcType -> TcM (TcCoercionN, TcType)

zonkTidyTcType :: TidyEnv -> TcType -> TcM (TidyEnv, TcType)

zonkTidyTcTypes :: TidyEnv -> [TcType] -> TcM (TidyEnv, [TcType])

zonkTidyOrigin :: TidyEnv -> CtOrigin -> TcM (TidyEnv, CtOrigin)

zonkTidyOrigins :: TidyEnv -> [CtOrigin] -> TcM (TidyEnv, [CtOrigin])

zonkTidyFRRInfos :: TidyEnv -> [FixedRuntimeRepErrorInfo] -> TcM (TidyEnv, [FixedRuntimeRepErrorInfo])

tidyEvVar :: TidyEnv -> EvVar -> EvVar

tidyCt :: TidyEnv -> Ct -> Ct

tidyHole :: TidyEnv -> Hole -> Hole

tidyDelayedError :: TidyEnv -> DelayedError -> DelayedError

zonkTcTyVar :: TcTyVar -> TcM TcType

zonkTcTyVars :: [TcTyVar] -> TcM [TcType]

zonkTcTyVarToTcTyVar :: HasDebugCallStack => TcTyVar -> TcM TcTyVar

zonkTcTyVarsToTcTyVars :: HasDebugCallStack => [TcTyVar] -> TcM [TcTyVar]

zonkInvisTVBinder :: VarBndr TcTyVar spec -> TcM (VarBndr TcTyVar spec)

zonkTyCoVarsAndFV :: TyCoVarSet -> TcM TyCoVarSet

zonkTcTypeAndFV :: TcType -> TcM DTyCoVarSet

zonkDTyCoVarSetAndFV :: DTyCoVarSet -> TcM DTyCoVarSet

zonkTyCoVarsAndFVList :: [TyCoVar] -> TcM [TyCoVar]

zonkTcType :: TcType -> TcM TcType

zonkTcTypes :: [TcType] -> TcM [TcType]

zonkCo :: Coercion -> TcM Coercion

zonkTyCoVarKind :: TyCoVar -> TcM TyCoVar

zonkEvVar :: EvVar -> TcM EvVar

zonkWC :: WantedConstraints -> TcM WantedConstraints

zonkImplication :: Implication -> TcM Implication

zonkSimples :: Cts -> TcM Cts

zonkId :: TcId -> TcM TcId

zonkCoVar :: CoVar -> TcM CoVar

zonkCt :: Ct -> TcM Ct

zonkSkolemInfo :: SkolemInfo -> TcM SkolemInfo

zonkSkolemInfoAnon :: SkolemInfoAnon -> TcM SkolemInfoAnon

defaultTyVar :: DefaultingStrategy -> TcTyVar -> TcM Bool

Default a type variable using the given defaulting strategy.

See Note [Type variable defaulting options] in GHC.Types.Basic.

promoteMetaTyVarTo :: TcLevel -> TcTyVar -> TcM Bool

promoteTyVarSet :: TcTyVarSet -> TcM Bool

quantifyTyVars :: SkolemInfo -> NonStandardDefaultingStrategy -> CandidatesQTvs -> TcM [TcTyVar]

isQuantifiableTv :: TcLevel -> TcTyVar -> Bool

zonkAndSkolemise :: SkolemInfo -> TcTyCoVar -> TcM TcTyCoVar

skolemiseQuantifiedTyVar :: SkolemInfo -> TcTyVar -> TcM TcTyVar

doNotQuantifyTyVars

Arguments

:: CandidatesQTvs

-> (TidyEnv -> TcM (TidyEnv, SDoc))

like "the class context (D a b, E foogle)"

-> TcM ()

candidateQTyVarsOfType :: TcType -> TcM CandidatesQTvs

Gathers free variables to use as quantification candidates (in quantifyTyVars). This might output the same var in both sets, if it's used in both a type and a kind. The variables to quantify must have a TcLevel strictly greater than the ambient level. (See Wrinkle in Note [Naughty quantification candidates]) See Note [CandidatesQTvs determinism and order] See Note [Dependent type variables]

candidateQTyVarsOfKind :: TcKind -> TcM CandidatesQTvs

Like candidateQTyVarsOfType, but consider every free variable to be dependent. This is appropriate when generalizing a *kind*, instead of a type. (That way, -XNoPolyKinds will default the variables to Type.)

candidateQTyVarsOfTypes :: [Type] -> TcM CandidatesQTvs

Like candidateQTyVarsOfType, but over a list of types The variables to quantify must have a TcLevel strictly greater than the ambient level. (See Wrinkle in Note [Naughty quantification candidates])

candidateQTyVarsOfKinds :: [TcKind] -> TcM CandidatesQTvs

candidateQTyVarsWithBinders :: [TyVar] -> Type -> TcM CandidatesQTvs

data CandidatesQTvs

Constructors

DV

Fields

• dv_kvs :: DTyVarSet
• dv_tvs :: DTyVarSet
• dv_cvs :: CoVarSet

Instances

Monoid CandidatesQTvs

Defined in GHC.Tc.Utils.TcMType

Methods

mempty :: CandidatesQTvs

mappend :: CandidatesQTvs -> CandidatesQTvs -> CandidatesQTvs

mconcat :: [CandidatesQTvs] -> CandidatesQTvs

Semigroup CandidatesQTvs

Defined in GHC.Tc.Utils.TcMType

Methods

(<>) :: CandidatesQTvs -> CandidatesQTvs -> CandidatesQTvs

sconcat :: NonEmpty CandidatesQTvs -> CandidatesQTvs

stimes :: Integral b => b -> CandidatesQTvs -> CandidatesQTvs

Outputable CandidatesQTvs

Defined in GHC.Tc.Utils.TcMType

Methods

ppr :: CandidatesQTvs -> SDoc

delCandidates :: CandidatesQTvs -> [Var] -> CandidatesQTvs

candidateKindVars :: CandidatesQTvs -> TyVarSet

partitionCandidates :: CandidatesQTvs -> (TyVar -> Bool) -> (TyVarSet, CandidatesQTvs)

checkTypeHasFixedRuntimeRep :: FixedRuntimeRepProvenance -> Type -> TcM ()

Check that the specified type has a fixed runtime representation.

If it isn't, throw a representation-polymorphism error appropriate for the context (as specified by the FixedRuntimeRepProvenance).

Unlike the other representation polymorphism checks, which can emit new Wanted constraints to be solved by the constraint solver, this function does not emit any constraints: it has enough information to immediately make a decision.

See (1) in Note [Representation polymorphism checking] in GHC.Tc.Utils.Concrete

anyUnfilledCoercionHoles :: RewriterSet -> TcM Bool

Check whether any coercion hole in a RewriterSet is still unsolved. Does this by recursively looking through filled coercion holes until one is found that is not yet filled in, at which point this aborts.