Control.Monad.Exception.Synchronous

Synchronous exceptions immediately abort a series of computations. We provide monads for describing this behaviour.

Plain monad

data Exceptional e a

Like Either, but explicitly intended for handling of exceptional results. In contrast to Either we do not support fail. Calling fail in the Exceptional monad is an error. This way, we do not require that an exception can be derived from a String, yet, we require no constraint on the exception type at all.

Constructors

Success a

Exception e

Instances

Monad (Exceptional e)

Functor (Exceptional e)

MonadFix (Exceptional e)

Applicative (Exceptional e)

(Eq e, Eq a) => Eq (Exceptional e a)

(Show e, Show a) => Show (Exceptional e a)

fromMaybe :: e -> Maybe a -> Exceptional e a

fromEither :: Either e a -> Exceptional e a

toEither :: Exceptional e a -> Either e a

getExceptionNull :: Exceptional e () -> Maybe e

useful in connection with Control.Monad.Exception.Asynchronous.continue

force :: Exceptional e a -> Exceptional e a

If you are sure that the value is always a Success you can tell that the run-time system thus making your program lazy. However, try to avoid this function by using catch and friends, since this function is partial.

mapException :: (e0 -> e1) -> Exceptional e0 a -> Exceptional e1 a

mapExceptional :: (e0 -> e1) -> (a -> b) -> Exceptional e0 a -> Exceptional e1 b

throw :: e -> Exceptional e a

catch :: Exceptional e0 a -> (e0 -> Exceptional e1 a) -> Exceptional e1 a

resolve :: (e -> a) -> Exceptional e a -> a

Monad transformer

newtype ExceptionalT e m a

like ErrorT, but ExceptionalT is the better name in order to distinguish from real (programming) errors

Constructors

ExceptionalT

Fields

runExceptionalT :: m (Exceptional e a)

Instances

MonadTrans (ExceptionalT e)

Monad m => Monad (ExceptionalT e m)

Functor m => Functor (ExceptionalT e m)

MonadFix m => MonadFix (ExceptionalT e m)

Applicative m => Applicative (ExceptionalT e m)

(MonadSIO m, ContainsIOException e) => MonadIO (ExceptionalT e m)

fromErrorT :: Monad m => ErrorT e m a -> ExceptionalT e m a

toErrorT :: Monad m => ExceptionalT e m a -> ErrorT e m a

fromEitherT :: Monad m => m (Either e a) -> ExceptionalT e m a

toEitherT :: Monad m => ExceptionalT e m a -> m (Either e a)

forceT :: Monad m => ExceptionalT e m a -> ExceptionalT e m a

see force

mapExceptionT :: Monad m => (e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a

mapExceptionalT :: (m (Exceptional e0 a) -> n (Exceptional e1 b)) -> ExceptionalT e0 m a -> ExceptionalT e1 n b

throwT :: Monad m => e -> ExceptionalT e m a

catchT :: Monad m => ExceptionalT e0 m a -> (e0 -> ExceptionalT e1 m a) -> ExceptionalT e1 m a

bracketT :: Monad m => ExceptionalT e m h -> (h -> ExceptionalT e m ()) -> (h -> ExceptionalT e m a) -> ExceptionalT e m a

If the enclosed monad has custom exception facilities, they could skip the cleanup code. Make sure, that this cannot happen by choosing an appropriate monad.

resolveT :: Monad m => (e -> m a) -> ExceptionalT e m a -> m a

tryT :: Monad m => ExceptionalT e m a -> m (Exceptional e a)

manyT

Arguments

:: Monad m

=> (e0 -> Maybe e1)

exception handler

-> (a -> b -> b)

cons function

-> b

empty

-> ExceptionalT e0 m a

atomic action to repeat

-> ExceptionalT e1 m b

Repeat an action until an exception occurs. Initialize the result with empty and add new elements using cons (e.g. [] and (:)). The exception handler decides whether the terminating exception is re-raised (Just) or catched (Nothing).