Control.Monad.Ology.General.Exception

Documentation

class Monad m => MonadException m where

Pretty much every monad can be made an instance of this class.

Associated Types

type Exc m :: Type

The type of all exceptions of this monad.

Methods

throwExc :: Exc m -> m a

catchExc :: m a -> (Exc m -> m a) -> m a

Instances

MonadException Identity

Defined in Control.Monad.Ology.General.Exception.Class

Associated Types

type Exc Identity

Methods

throwExc :: Exc Identity -> Identity a

catchExc :: Identity a -> (Exc Identity -> Identity a) -> Identity a

MonadException IO

Defined in Control.Monad.Ology.General.Exception.Class

Associated Types

type Exc IO

Methods

throwExc :: Exc IO -> IO a

catchExc :: IO a -> (Exc IO -> IO a) -> IO a

MonadException Maybe

Defined in Control.Monad.Ology.General.Exception.Class

Associated Types

type Exc Maybe

Methods

throwExc :: Exc Maybe -> Maybe a

catchExc :: Maybe a -> (Exc Maybe -> Maybe a) -> Maybe a

MonadException []

Defined in Control.Monad.Ology.General.Exception.Class

Associated Types

type Exc []

Methods

throwExc :: Exc [] -> [a]

catchExc :: [a] -> (Exc [] -> [a]) -> [a]

(MonadInner inner, MonadException inner) => TransConstraint MonadException (ComposeInner inner)

Defined in Control.Monad.Ology.Specific.ComposeInner

Methods

hasTransConstraint :: forall (m :: Type -> Type). MonadException m => Dict (MonadException (ComposeInner inner m))

TransConstraint MonadException (LifecycleT :: (Type -> Type) -> Type -> TYPE LiftedRep)

Defined in Control.Monad.Ology.Specific.LifecycleT

Methods

hasTransConstraint :: forall (m :: Type -> Type). MonadException m => Dict (MonadException (LifecycleT m))

TransConstraint MonadException (ExceptT e)

Defined in Control.Monad.Ology.Specific.ExceptT

Methods

hasTransConstraint :: forall (m :: Type -> Type). MonadException m => Dict (MonadException (ExceptT e m))

TransConstraint MonadException (IdentityT :: (Type -> Type) -> Type -> Type)

Defined in Control.Monad.Ology.Specific.IdentityT

Methods

hasTransConstraint :: forall (m :: Type -> Type). MonadException m => Dict (MonadException (IdentityT m))

TransConstraint MonadException (ReaderT r)

Defined in Control.Monad.Ology.Specific.ReaderT

Methods

hasTransConstraint :: forall (m :: Type -> Type). MonadException m => Dict (MonadException (ReaderT r m))

TransConstraint MonadException (StateT s)

Defined in Control.Monad.Ology.Specific.StateT

Methods

hasTransConstraint :: forall (m :: Type -> Type). MonadException m => Dict (MonadException (StateT s m))

Monoid w => TransConstraint MonadException (WriterT w)

Defined in Control.Monad.Ology.Specific.WriterT

Methods

hasTransConstraint :: forall (m :: Type -> Type). MonadException m => Dict (MonadException (WriterT w m))

MonadException (Either e)

Defined in Control.Monad.Ology.General.Exception.Class

Associated Types

type Exc (Either e)

Methods

throwExc :: Exc (Either e) -> Either e a

catchExc :: Either e a -> (Exc (Either e) -> Either e a) -> Either e a

MonadException (Result e)

Defined in Control.Monad.Ology.General.Exception.Class

Associated Types

type Exc (Result e)

Methods

throwExc :: Exc (Result e) -> Result e a

catchExc :: Result e a -> (Exc (Result e) -> Result e a) -> Result e a

MonadException m => MonadException (MaybeT m)

Defined in Control.Monad.Ology.Specific.MaybeT

Associated Types

type Exc (MaybeT m)

Methods

throwExc :: Exc (MaybeT m) -> MaybeT m a

catchExc :: MaybeT m a -> (Exc (MaybeT m) -> MaybeT m a) -> MaybeT m a

Monoid p => MonadException ((,) p)

Defined in Control.Monad.Ology.General.Exception.Class

Associated Types

type Exc ((,) p)

Methods

throwExc :: Exc ((,) p) -> (p, a)

catchExc :: (p, a) -> (Exc ((,) p) -> (p, a)) -> (p, a)

(MonadInner inner, MonadException inner, MonadException m) => MonadException (ComposeInner inner m)

Defined in Control.Monad.Ology.Specific.ComposeInner

Associated Types

type Exc (ComposeInner inner m)

Methods

throwExc :: Exc (ComposeInner inner m) -> ComposeInner inner m a

catchExc :: ComposeInner inner m a -> (Exc (ComposeInner inner m) -> ComposeInner inner m a) -> ComposeInner inner m a

(MonadOuter outer, MonadException m) => MonadException (ComposeOuter outer m)

Defined in Control.Monad.Ology.Specific.ComposeOuter

Associated Types

type Exc (ComposeOuter outer m)

Methods

throwExc :: Exc (ComposeOuter outer m) -> ComposeOuter outer m a

catchExc :: ComposeOuter outer m a -> (Exc (ComposeOuter outer m) -> ComposeOuter outer m a) -> ComposeOuter outer m a

MonadException m => MonadException (LifecycleT m)

Defined in Control.Monad.Ology.Specific.LifecycleT

Associated Types

type Exc (LifecycleT m)

Methods

throwExc :: Exc (LifecycleT m) -> LifecycleT m a

catchExc :: LifecycleT m a -> (Exc (LifecycleT m) -> LifecycleT m a) -> LifecycleT m a

MonadException m => MonadException (WithT m)

Defined in Control.Monad.Ology.Specific.WithT

Associated Types

type Exc (WithT m)

Methods

throwExc :: Exc (WithT m) -> WithT m a

catchExc :: WithT m a -> (Exc (WithT m) -> WithT m a) -> WithT m a

MonadException m => MonadException (ExceptT e m)

Defined in Control.Monad.Ology.Specific.ExceptT

Associated Types

type Exc (ExceptT e m)

Methods

throwExc :: Exc (ExceptT e m) -> ExceptT e m a

catchExc :: ExceptT e m a -> (Exc (ExceptT e m) -> ExceptT e m a) -> ExceptT e m a

MonadException m => MonadException (IdentityT m)

Defined in Control.Monad.Ology.Specific.IdentityT

Associated Types

type Exc (IdentityT m)

Methods

throwExc :: Exc (IdentityT m) -> IdentityT m a

catchExc :: IdentityT m a -> (Exc (IdentityT m) -> IdentityT m a) -> IdentityT m a

MonadException m => MonadException (ReaderT r m)

Defined in Control.Monad.Ology.Specific.ReaderT

Associated Types

type Exc (ReaderT r m)

Methods

throwExc :: Exc (ReaderT r m) -> ReaderT r m a

catchExc :: ReaderT r m a -> (Exc (ReaderT r m) -> ReaderT r m a) -> ReaderT r m a

MonadException m => MonadException (StateT s m)

Defined in Control.Monad.Ology.Specific.StateT

Associated Types

type Exc (StateT s m)

Methods

throwExc :: Exc (StateT s m) -> StateT s m a

catchExc :: StateT s m a -> (Exc (StateT s m) -> StateT s m a) -> StateT s m a

(Monoid w, MonadException m) => MonadException (WriterT w m)

Defined in Control.Monad.Ology.Specific.WriterT

Associated Types

type Exc (WriterT w m)

Methods

throwExc :: Exc (WriterT w m) -> WriterT w m a

catchExc :: WriterT w m a -> (Exc (WriterT w m) -> WriterT w m a) -> WriterT w m a

MonadException ((->) r)

Defined in Control.Monad.Ology.General.Exception.Class

Associated Types

type Exc ((->) r)

Methods

throwExc :: Exc ((->) r) -> r -> a

catchExc :: (r -> a) -> (Exc ((->) r) -> r -> a) -> r -> a

catchSomeExc :: forall m a. MonadException m => m a -> (Exc m -> m (Maybe a)) -> m a

Catch all exceptions, optionally returning or re-throwing.

fromResultExc :: forall m a. MonadException m => Result (Exc m) a -> m a

tryExc :: forall m a. MonadException m => m a -> m (Result (Exc m) a)

Catch all exceptions as a Result.

onException :: forall m a. MonadException m => m a -> m () -> m a

Run the handler on exception. Does not mask asynchronous exceptions on the handler.

catchPureError :: a -> IO (Maybe SomeException)

This catches certain "bottom values". Of course, since non-termination is bottom, this cannot catch all bottoms.

mask :: forall m b. MonadTunnelIO m => ((forall a. m a -> m a) -> m b) -> m b

Run with asynchronous exceptions masked, passing an unmask function.

bracket :: forall m a b. (MonadException m, MonadTunnelIO m) => m a -> (a -> m ()) -> (a -> m b) -> m b

Bracket an operation with before and after operations. The whole thing is masked, with the main operation unmasked.

finally :: forall m a. (MonadException m, MonadTunnelIO m) => m a -> m () -> m a

Variant of bracket.

bracket_ :: forall m. (MonadException m, MonadTunnelIO m) => m () -> m () -> m --> m

Variant of bracket.

bracketNoMask :: forall m a b. MonadException m => m a -> (a -> m ()) -> (a -> m b) -> m b

Like bracket, but doesn't mask asynchronous exceptions.

bracketNoMask_ :: forall m. MonadException m => m () -> m () -> m --> m

Variant of bracketNoMask.

bracketFake :: forall m a b. Monad m => m a -> (a -> m ()) -> (a -> m b) -> m b

Like bracketNoMask, but doesn't catch any exceptions.

data SomeException

The SomeException type is the root of the exception type hierarchy. When an exception of type e is thrown, behind the scenes it is encapsulated in a SomeException.

Instances

Exception SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

toException :: SomeException -> SomeException

fromException :: SomeException -> Maybe SomeException

displayException :: SomeException -> String

Show SomeException

Since: base-3.0

Defined in GHC.Exception.Type

Methods

showsPrec :: Int -> SomeException -> ShowS

show :: SomeException -> String

showList :: [SomeException] -> ShowS

evaluate :: a -> IO a

Evaluate the argument to weak head normal form.

evaluate is typically used to uncover any exceptions that a lazy value may contain, and possibly handle them.

evaluate only evaluates to weak head normal form. If deeper evaluation is needed, the force function from Control.DeepSeq may be handy:

evaluate $ force x

There is a subtle difference between evaluate x and return $! x, analogous to the difference between throwIO and throw. If the lazy value x throws an exception, return $! x will fail to return an IO action and will throw an exception instead. evaluate x, on the other hand, always produces an IO action; that action will throw an exception upon execution iff x throws an exception upon evaluation.

The practical implication of this difference is that due to the imprecise exceptions semantics,

(return $! error "foo") >> error "bar"

may throw either "foo" or "bar", depending on the optimizations performed by the compiler. On the other hand,

evaluate (error "foo") >> error "bar"

is guaranteed to throw "foo".

The rule of thumb is to use evaluate to force or handle exceptions in lazy values. If, on the other hand, you are forcing a lazy value for efficiency reasons only and do not care about exceptions, you may use return $! x.