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

buildImplication :: SkolemInfo -> [TcTyVar] -> [EvVar] -> TcM result -> TcM (Bag Implication, 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