Control.Monad.Exception.Synchronous

Synchronous exceptions immediately abort a series of computations. We provide monads for describing this behaviour. In contrast to ErrorT from mtl or transformers package we do not pose restrictions on the exception type.

How to tell, that a function can possibly throw more than one (kind of) exception?

If you would use the exception type (Either ParserException IOError) then this is different from (Either IOError ParserException). Thus we recommned using type classes for exceptions. Then you can use one type containing all exceptions in an application, but the type signature still tells which exceptions are actually possible. Examples:

parser :: ParserException e => ExceptionalT e ParserMonad a

getLine :: IOException e => ExceptionalT e IO String

fileParser :: (ParserException e, IOException e) => ExceptionalT e IO String

You can remove single exceptions from the set, but with Haskell 98 you need instances for all the other constraints in the exception constraint set. There is a more advanced approach, that allows removing exceptions constraints without a quadratic growth of instances. It uses some non-Haskell-98 type hackery, see the exception package by Joseph Iborra. Fortunately, you use this package in every case and let the user decide whether he wants Haskell 98 or non-standard way of handling exceptions.

See also: https://wiki.haskell.org/Exception.

Documentation

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

MonadFix (Exceptional e)

I think it is not a good idea to use this instance, maybe we shoul remove it. It expects that the constructor is Success and the result is undefined otherwise. But if the constructor must always be Success, why using Exceptional then, at all?

Defined in Control.Monad.Exception.Synchronous

Methods

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

Applicative (Exceptional e)

Defined in Control.Monad.Exception.Synchronous

Methods

pure :: a -> Exceptional e a

(<*>) :: Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b

liftA2 :: (a -> b -> c) -> Exceptional e a -> Exceptional e b -> Exceptional e c

(*>) :: Exceptional e a -> Exceptional e b -> Exceptional e b

(<*) :: Exceptional e a -> Exceptional e b -> Exceptional e a

Functor (Exceptional e)

Defined in Control.Monad.Exception.Synchronous

Methods

fmap :: (a -> b) -> Exceptional e a -> Exceptional e b

(<$) :: a -> Exceptional e b -> Exceptional e a

Monad (Exceptional e)

Defined in Control.Monad.Exception.Synchronous

Methods

(>>=) :: Exceptional e a -> (a -> Exceptional e b) -> Exceptional e b

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

return :: a -> Exceptional e a

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

Defined in Control.Monad.Exception.Synchronous

Methods

showsPrec :: Int -> Exceptional e a -> ShowS

show :: Exceptional e a -> String

showList :: [Exceptional e a] -> ShowS

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

Defined in Control.Monad.Exception.Synchronous

Methods

rnf :: Exceptional e a -> ()

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

Defined in Control.Monad.Exception.Synchronous

Methods

(==) :: Exceptional e a -> Exceptional e a -> Bool

(/=) :: Exceptional e a -> Exceptional e a -> Bool

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

toMaybe :: Exceptional e a -> Maybe a

fromEither :: Either e a -> Exceptional e a

toEither :: Exceptional e a -> Either e a

fromExitCode :: ExitCode -> Exceptional Int ()

toExitCode :: Exceptional Int () -> ExitCode

getExceptionNull :: Exceptional e () -> Maybe e

useful in connection with continue

switch :: (e -> b) -> (a -> b) -> Exceptional e a -> b

Counterpart to either for Either.

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

assert :: e -> Bool -> Exceptional e ()

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

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

merge :: Monoid e => Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b infixl 4

see mergeT

alternative :: Exceptional e a -> Exceptional e a -> Exceptional e a infixl 3

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)

Defined in Control.Monad.Exception.Synchronous

Methods

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

MonadFix m => MonadFix (ExceptionalT e m)

Same restrictions applies as for instance MonadFix (Exceptional e a).

Defined in Control.Monad.Exception.Synchronous

Methods

mfix :: (a -> ExceptionalT e m a) -> ExceptionalT e m a

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

Defined in System.IO.Straight

Methods

liftIO :: IO a -> ExceptionalT e m a

Applicative m => Applicative (ExceptionalT e m)

Defined in Control.Monad.Exception.Synchronous

Methods

pure :: a -> ExceptionalT e m a

(<*>) :: ExceptionalT e m (a -> b) -> ExceptionalT e m a -> ExceptionalT e m b

liftA2 :: (a -> b -> c) -> ExceptionalT e m a -> ExceptionalT e m b -> ExceptionalT e m c

(*>) :: ExceptionalT e m a -> ExceptionalT e m b -> ExceptionalT e m b

(<*) :: ExceptionalT e m a -> ExceptionalT e m b -> ExceptionalT e m a

Functor m => Functor (ExceptionalT e m)

Defined in Control.Monad.Exception.Synchronous

Methods

fmap :: (a -> b) -> ExceptionalT e m a -> ExceptionalT e m b

(<$) :: a -> ExceptionalT e m b -> ExceptionalT e m a

Monad m => Monad (ExceptionalT e m)

Defined in Control.Monad.Exception.Synchronous

Methods

(>>=) :: ExceptionalT e m a -> (a -> ExceptionalT e m b) -> ExceptionalT e m b

(>>) :: ExceptionalT e m a -> ExceptionalT e m b -> ExceptionalT e m b

return :: a -> ExceptionalT e m a

fromMaybeT :: Monad m => e -> MaybeT m a -> ExceptionalT e m a

toMaybeT :: Monad m => ExceptionalT e m a -> MaybeT m a

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)

fromExitCodeT :: Functor m => m ExitCode -> ExceptionalT Int m ()

toExitCodeT :: Functor m => ExceptionalT Int m () -> m ExitCode

liftT :: Monad m => Exceptional e a -> ExceptionalT e m a

switchT :: Monad m => (e -> m b) -> (a -> m b) -> ExceptionalT e m a -> m b

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

assertT :: Monad m => e -> Bool -> ExceptionalT e m ()

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

manyMonoidT

Arguments

:: (Monad m, Monoid a)

=> (e0 -> Maybe e1)

exception handler

-> ExceptionalT e0 m a

atomic action to repeat

-> ExceptionalT e1 m a

mergeT :: (Monoid e, Monad m) => ExceptionalT e m (a -> b) -> ExceptionalT e m a -> ExceptionalT e m b infixl 4

This combines two actions similar to Applicative's *. The result action fails if one of the input action fails, but both actions are executed. E.g. consider a compiler that emits all errors that can be detected independently, but eventually aborts if there is at least one error.

The exception type e might be a list type, or an Endo type that implements a difflist.

alternativeT :: Monad m => ExceptionalT e m a -> ExceptionalT e m a -> ExceptionalT e m a infixl 3