Safe Haskell	None
Language	Haskell2010

TcUnify

Synopsis

Documentation

tcWrapResult :: HsExpr Name -> HsExpr TcId -> TcSigmaType -> ExpRhoType -> TcM (HsExpr TcId) Source #

tcWrapResultO :: CtOrigin -> HsExpr TcId -> TcSigmaType -> ExpRhoType -> TcM (HsExpr TcId) Source #

Sometimes we don't have a HsExpr Name to hand, and this is more convenient.

tcSkolemise Source #

Arguments

:: UserTypeCtxt
-> TcSigmaType
-> ([TcTyVar] -> TcType -> TcM result)	These are only ever used for scoped type variables.
-> TcM (HsWrapper, result)	The expression has type: spec_ty -> expected_ty

Take an "expected type" and strip off quantifiers to expose the type underneath, binding the new skolems for the thing_inside. The returned HsWrapper has type specific_ty -> expected_ty.

tcSkolemiseET :: UserTypeCtxt -> ExpSigmaType -> (ExpRhoType -> TcM result) -> TcM (HsWrapper, result) Source #

Variant of tcSkolemise that takes an ExpType

tcSubTypeHR Source #

Arguments

:: Outputable a
=> CtOrigin	of the actual type
-> Maybe a	If present, it has type ty_actual
-> TcSigmaType
-> ExpRhoType
-> TcM HsWrapper

Call this variant when you are in a higher-rank situation and you know the right-hand type is deeply skolemised.

tcSubType Source #

Arguments

:: Outputable a
=> UserTypeCtxt
-> Maybe a	If present, it has type ty_actual
-> TcSigmaType
-> ExpSigmaType
-> TcM HsWrapper

tcSubTypeO Source #

Arguments

:: CtOrigin	of the actual type
-> UserTypeCtxt	of the expected type
-> TcSigmaType
-> ExpSigmaType
-> TcM HsWrapper

tcSubType_NC :: UserTypeCtxt -> TcSigmaType -> ExpSigmaType -> TcM HsWrapper Source #

tcSubTypeDS Source #

Arguments

:: Outputable a
=> UserTypeCtxt
-> Maybe a	has type ty_actual
-> TcSigmaType
-> ExpRhoType
-> TcM HsWrapper

tcSubTypeDS_O :: Outputable a => CtOrigin -> UserTypeCtxt -> Maybe a -> TcSigmaType -> ExpRhoType -> TcM HsWrapper Source #

Like tcSubTypeDS, but takes a CtOrigin to use when instantiating the "actual" type

tcSubTypeDS_NC Source #

Arguments

:: Outputable a
=> UserTypeCtxt
-> Maybe a	If present, this has type ty_actual
-> TcSigmaType
-> ExpRhoType
-> TcM HsWrapper

tcSubTypeDS_NC_O :: Outputable a => CtOrigin -> UserTypeCtxt -> Maybe a -> TcSigmaType -> ExpRhoType -> TcM HsWrapper Source #

tcSubTypeET :: CtOrigin -> ExpSigmaType -> TcSigmaType -> TcM HsWrapper Source #

This is like tcSubType but accepts an ExpType as the actual type. You probably want this only when looking at patterns, never expressions.

tcSubTypeET_NC :: UserTypeCtxt -> ExpSigmaType -> TcSigmaType -> TcM HsWrapper Source #

This is like tcSubType but accepts an ExpType as the actual type. You probably want this only when looking at patterns, never expressions. Does not add context.

checkConstraints :: SkolemInfo -> [TcTyVar] -> [EvVar] -> TcM result -> TcM (TcEvBinds, result) Source #

buildImplicationFor :: TcLevel -> SkolemInfo -> [TcTyVar] -> [EvVar] -> WantedConstraints -> TcM (Bag Implication, TcEvBinds) Source #

unifyType_ Source #

Arguments

:: Outputable a
=> Maybe a	If present, has type `ty1`
-> TcTauType
-> TcTauType
-> TcM ()

Unify two types, discarding a resultant coercion. Any constraints generated will still need to be solved, however.

unifyType Source #

Arguments

:: Outputable a
=> Maybe a	If present, has type `ty1`
-> TcTauType
-> TcTauType
-> TcM TcCoercionN

unifyTheta :: TcThetaType -> TcThetaType -> TcM [TcCoercionN] Source #

unifyKind :: Outputable a => Maybe a -> TcKind -> TcKind -> TcM CoercionN Source #

noThing :: Maybe (HsExpr Name) Source #

Use this instead of Nothing when calling unifyType without a good "thing" (where the "thing" has the "actual" type passed in) This has an Outputable instance, avoiding amgiguity problems.

uType :: CtOrigin -> TypeOrKind -> TcType -> TcType -> TcM Coercion Source #

unifyExpType :: Outputable a => Maybe a -> TcTauType -> ExpType -> TcM TcCoercionN Source #

Variant of unifyType that takes an ExpType as its second type

tcInfer :: (ExpRhoType -> TcM a) -> TcM (a, TcType) Source #

Infer a type using a fresh ExpType See also Note [ExpType] in TcMType

matchExpectedListTy :: TcRhoType -> TcM (TcCoercionN, TcRhoType) Source #

matchExpectedPArrTy :: TcRhoType -> TcM (TcCoercionN, TcRhoType) Source #

matchExpectedTyConApp :: TyCon -> TcRhoType -> TcM (TcCoercionN, [TcSigmaType]) Source #

matchExpectedAppTy :: TcRhoType -> TcM (TcCoercion, (TcSigmaType, TcSigmaType)) Source #

matchExpectedFunTys :: SDoc -> Arity -> ExpRhoType -> ([ExpSigmaType] -> ExpRhoType -> TcM a) -> TcM (a, HsWrapper) Source #

matchActualFunTys :: Outputable a => SDoc -> CtOrigin -> Maybe a -> Arity -> TcSigmaType -> TcM (HsWrapper, [TcSigmaType], TcSigmaType) Source #

matchActualFunTysPart :: Outputable a => SDoc -> CtOrigin -> Maybe a -> Arity -> TcSigmaType -> [TcSigmaType] -> Arity -> TcM (HsWrapper, [TcSigmaType], TcSigmaType) Source #

Variant of matchActualFunTys that works when supplied only part (that is, to the right of some arrows) of the full function type

matchExpectedFunKind Source #

Arguments

:: Arity	# of args remaining, only for errors
-> TcType	type, only for errors
-> TcKind	function kind
-> TcM (Coercion, TcKind, TcKind)	co :: old_kind ~ arg -> res

Breaks apart a function kind into its pieces.

wrapFunResCoercion :: [TcType] -> HsWrapper -> TcM HsWrapper Source #