ghc-lib-0.20190523.1: The GHC API, decoupled from GHC versions

TcMType

Synopsis

# Documentation

type TcTyVar = Var #

Type variable that might be a metavariable

type TcKind = Kind #

type TcType = Type #

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

data ExpType #

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

Constructors

 Check TcType Infer !InferResult
Instances
 Instance detailsDefined in TcType Methodsppr :: ExpType -> SDoc #

Make an ExpType suitable for checking.

Make an ExpType suitable for inferring a type of kind * or #.

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

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.

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

Returns the expected type when in checking mode.

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

Turn a (Infer hole) type into a (Check alpha), where alpha is a fresh unification variable

newHoleCt :: Hole -> Id -> Type -> TcM Ct Source #

Create a new CHoleCan Ct.

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

Emits a new equality constraint

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

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

Put a value in a coercion hole

Is a coercion hole filled in?

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

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

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.

Arguments

 :: ([TyVar] -> TcM (TCvSubst, [TcTyVar])) How to instantiate the type variables -> Id Type to instantiate -> TcM ([(Name, TcTyVar)], TcThetaType, TcType) Result (type vars, preds (incl equalities), rho)

tcInstSkolTyVars :: [TyVar] -> TcM (TCvSubst, [TcTyVar]) Source #

Given a list of [TyVar], skolemize the type variables, returning a substitution mapping the original tyvars to the skolems, and the list of newly bound skolems.

freshenTyVarBndrs :: [TyVar] -> TcM (TCvSubst, [TyVar]) Source #

Give fresh uniques to a bunch of TyVars, but they stay as TyVars, rather than becoming TcTyVars Used in FamInst.newFamInst, and Inst.newClsInst

freshenCoVarBndrsX :: TCvSubst -> [CoVar] -> TcM (TCvSubst, [CoVar]) Source #

Give fresh uniques to a bunch of CoVars Used in FamInst.newFamInst

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. See Note [CandidatesQTvs determinism and order] See Note [Dependent type variables]

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.)

Like splitDepVarsOfType, but over a list of types

Constructors

 DV Fieldsdv_kvs :: DTyVarSet dv_tvs :: DTyVarSet dv_cvs :: CoVarSet
Instances
 Source # Instance detailsDefined in TcMType Methodsstimes :: Integral b => b -> CandidatesQTvs -> CandidatesQTvs # Source # Instance detailsDefined in TcMType Methods Source # Instance detailsDefined in TcMType Methods

Zonk a coercion -- really, just zonk any types in the coercion

tcGetGlobalTyCoVars returns a fully-zonked set of *scoped* tyvars free in the environment. To improve subsequent calls to the same function it writes the zonked set back into the environment. Note that this returns all variables free in anything (term-level or type-level) in scope. We thus don't have to worry about clashes with things that are not in scope, because if they are reachable, then they'll be returned here. NB: This is closed over kinds, so it can return unification variables mentioned in the kinds of in-scope tyvars.

According to the rules around representation polymorphism (see https://gitlab.haskell.org/ghc/ghc/wikis/no-sub-kinds), no binder can have a representation-polymorphic type. This check ensures that we respect this rule. It is a bit regrettable that this error occurs in zonking, after which we should have reported all errors. But it's hard to see where else to do it, because this can be discovered only after all solving is done. And, perhaps most importantly, this isn't really a compositional property of a type system, so it's not a terrible surprise that the check has to go in an awkward spot.

checkForLevPolyX :: Monad m => (SDoc -> m ()) -> SDoc -> Type -> m () Source #