Control.Monad.Except
- Package
- purescript-transformers
- Repository
- purescript/purescript-transformers
#Except Source
type Except e = ExceptT e Identity
A parametrizable exception monad; computations are either exceptions or
pure values. If an exception is thrown (see throwError
), the computation
terminates with that value. Exceptions may also be caught with catchError
,
allowing the computation to resume and exit successfully.
The type parameter e
is the type of exceptions, and a
is the type
of successful results.
A mechanism for trying many different computations until one succeeds is
provided via the Alt
instance, specifically the (<|>)
function.
The first computation to succeed is returned; if all fail, the exceptions
are combined using their Semigroup
instance. The Plus
instance goes
further and adds the possibility of a computation failing with an 'empty'
exception; naturally, this requires the stronger constraint of a Monoid
instance for the exception type.
#withExcept Source
withExcept :: forall e e' a. (e -> e') -> Except e a -> Except e' a
Transform any exceptions thrown by an Except
computation using the given function.
Re-exports from Control.Monad.Error.Class
#MonadError Source
class MonadError :: Type -> (Type -> Type) -> Constraint
class (MonadThrow e m) <= MonadError e m | m -> e where
The MonadError
type class represents those monads which support catching
errors.
catchError x f
calls the error handlerf
if an error is thrown during the evaluation ofx
.
An implementation is provided for ExceptT
, and for other monad transformers
defined in this library.
Laws:
- Catch:
catchError (throwError e) f = f e
- Pure:
catchError (pure a) f = pure a
Members
catchError :: forall a. m a -> (e -> m a) -> m a
Instances
#throwError Source
throwError :: forall e m a. MonadThrow e m => e -> m a
#catchJust Source
catchJust :: forall e m a b. MonadError e m => (e -> Maybe b) -> m a -> (b -> m a) -> m a
This function allows you to provide a predicate for selecting the exceptions that you're interested in, and handle only those exceptons. If the inner computation throws an exception, and the predicate returns Nothing, then the whole computation will still fail with that exception.
Re-exports from Control.Monad.Except.Trans
#ExceptT Source
newtype ExceptT :: Type -> (Type -> Type) -> Type -> Type
newtype ExceptT e m a
A monad transformer which adds exceptions to other monads, in the same way
as Except
. As before, e
is the type of exceptions, and a
is the type
of successful results. The new type parameter m
is the inner monad that
computations run in.
Constructors
Instances
Newtype (ExceptT e m a) _
(Functor m) => Functor (ExceptT e m)
(Monad m) => Apply (ExceptT e m)
(Monad m) => Applicative (ExceptT e m)
(Monad m) => Bind (ExceptT e m)
(Monad m) => Monad (ExceptT e m)
(MonadRec m) => MonadRec (ExceptT e m)
(Semigroup e, Monad m) => Alt (ExceptT e m)
(Monoid e, Monad m) => Plus (ExceptT e m)
(Monoid e, Monad m) => Alternative (ExceptT e m)
(Monoid e, Monad m) => MonadPlus (ExceptT e m)
MonadTrans (ExceptT e)
(MonadEffect m) => MonadEffect (ExceptT e m)
(MonadCont m) => MonadCont (ExceptT e m)
(Monad m) => MonadThrow e (ExceptT e m)
(Monad m) => MonadError e (ExceptT e m)
(MonadAsk r m) => MonadAsk r (ExceptT e m)
(MonadReader r m) => MonadReader r (ExceptT e m)
(MonadState s m) => MonadState s (ExceptT e m)
(MonadTell w m) => MonadTell w (ExceptT e m)
(MonadWriter w m) => MonadWriter w (ExceptT e m)
(Monad m, Semigroup a) => Semigroup (ExceptT e m a)
(Monad m, Monoid a) => Monoid (ExceptT e m a)
(MonadST s m) => MonadST s (ExceptT e m)
#MonadTrans Source
class MonadTrans :: ((Type -> Type) -> Type -> Type) -> Constraint
class MonadTrans t where
The MonadTrans
type class represents monad transformers.
A monad transformer is a type constructor of kind (* -> *) -> * -> *
, which
takes a Monad
as its first argument, and returns another Monad
.
This allows us to add additional effects to an existing monad. By iterating this process, we create monad transformer stacks, which contain all of the effects required for a particular computation.
The laws state that lift
is a Monad
morphism.
Laws:
lift (pure a) = pure a
lift (do { x <- m ; y }) = do { x <- lift m ; lift y }
Members
#withExceptT Source
withExceptT :: forall e e' m a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
Transform any exceptions thrown by an ExceptT
computation using the given function.
#runExceptT Source
runExceptT :: forall e m a. ExceptT e m a -> m (Either e a)
The inverse of ExceptT
. Run a computation in the ExceptT
monad.
- Modules
- Control.
Comonad. Env - Control.
Comonad. Env. Class - Control.
Comonad. Env. Trans - Control.
Comonad. Store - Control.
Comonad. Store. Class - Control.
Comonad. Store. Trans - Control.
Comonad. Traced - Control.
Comonad. Traced. Class - Control.
Comonad. Traced. Trans - Control.
Comonad. Trans. Class - Control.
Monad. Cont - Control.
Monad. Cont. Class - Control.
Monad. Cont. Trans - Control.
Monad. Error. Class - Control.
Monad. Except - Control.
Monad. Except. Trans - Control.
Monad. Identity. Trans - Control.
Monad. List. Trans - Control.
Monad. Maybe. Trans - Control.
Monad. RWS - Control.
Monad. RWS. Trans - Control.
Monad. Reader - Control.
Monad. Reader. Class - Control.
Monad. Reader. Trans - Control.
Monad. State - Control.
Monad. State. Class - Control.
Monad. State. Trans - Control.
Monad. Trans. Class - Control.
Monad. Writer - Control.
Monad. Writer. Class - Control.
Monad. Writer. Trans