{-# LANGUAGE ExistentialQuantification, ScopedTypeVariables, MagicHash #-}
module Control.Monad.CatchIO
(
MonadCatchIO(..)
, E.Exception(..)
, throw
, try, tryJust
, Handler(..), catches
, bracket
, bracket_
, bracketOnError
, finally
, onException
)
where
import Prelude hiding ( catch )
import Control.Applicative ((<$>))
import qualified Control.Exception.Extensible as E
import Control.Monad.IO.Class (MonadIO,liftIO)
import Control.Monad.Trans.Cont (ContT(ContT) ,runContT ,mapContT )
import Control.Monad.Trans.Error (ErrorT ,runErrorT ,mapErrorT ,Error)
import Control.Monad.Trans.Identity (IdentityT ,runIdentityT,mapIdentityT)
import Control.Monad.Trans.List (ListT(ListT) ,runListT ,mapListT )
import Control.Monad.Trans.Maybe (MaybeT ,runMaybeT ,mapMaybeT )
import Control.Monad.Trans.RWS (RWST(RWST) ,runRWST ,mapRWST )
import qualified Control.Monad.Trans.RWS.Strict as Strict (RWST(RWST) ,runRWST ,mapRWST )
import Control.Monad.Trans.Reader (ReaderT(ReaderT),runReaderT ,mapReaderT )
import Control.Monad.Trans.State (StateT(StateT) ,runStateT ,mapStateT )
import qualified Control.Monad.Trans.State.Strict as Strict (StateT(StateT) ,runStateT ,mapStateT )
import Control.Monad.Trans.Writer (WriterT ,runWriterT ,mapWriterT )
import qualified Control.Monad.Trans.Writer.Strict as Strict (WriterT ,runWriterT ,mapWriterT )
import Data.Monoid (Monoid)
import GHC.Base (maskAsyncExceptions#)
import GHC.IO (unsafeUnmask,IO(IO))
class MonadIO m => MonadCatchIO m where
catch :: E.Exception e => m a -> (e -> m a) -> m a
block :: m a -> m a
unblock :: m a -> m a
instance MonadCatchIO IO where
catch :: IO a -> (e -> IO a) -> IO a
catch = IO a -> (e -> IO a) -> IO a
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
E.catch
block :: IO a -> IO a
block = \ (IO io :: State# RealWorld -> (# State# RealWorld, a #)
io) -> (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
forall a. (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
IO ((State# RealWorld -> (# State# RealWorld, a #)) -> IO a)
-> (State# RealWorld -> (# State# RealWorld, a #)) -> IO a
forall a b. (a -> b) -> a -> b
$ (State# RealWorld -> (# State# RealWorld, a #))
-> State# RealWorld -> (# State# RealWorld, a #)
forall a.
(State# RealWorld -> (# State# RealWorld, a #))
-> State# RealWorld -> (# State# RealWorld, a #)
maskAsyncExceptions# State# RealWorld -> (# State# RealWorld, a #)
io
unblock :: IO a -> IO a
unblock = IO a -> IO a
forall a. IO a -> IO a
unsafeUnmask
instance MonadCatchIO m => MonadCatchIO (ContT r m) where
m :: ContT r m a
m catch :: ContT r m a -> (e -> ContT r m a) -> ContT r m a
`catch` f :: e -> ContT r m a
f = ((a -> m r) -> m r) -> ContT r m a
forall k (r :: k) (m :: k -> *) a.
((a -> m r) -> m r) -> ContT r m a
ContT (((a -> m r) -> m r) -> ContT r m a)
-> ((a -> m r) -> m r) -> ContT r m a
forall a b. (a -> b) -> a -> b
$ \c :: a -> m r
c -> ContT r m a -> (a -> m r) -> m r
forall k (r :: k) (m :: k -> *) a. ContT r m a -> (a -> m r) -> m r
runContT ContT r m a
m a -> m r
c m r -> (e -> m r) -> m r
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> ContT r m a -> (a -> m r) -> m r
forall k (r :: k) (m :: k -> *) a. ContT r m a -> (a -> m r) -> m r
runContT (e -> ContT r m a
f e
e) a -> m r
c
block :: ContT r m a -> ContT r m a
block = (m r -> m r) -> ContT r m a -> ContT r m a
forall k (m :: k -> *) (r :: k) a.
(m r -> m r) -> ContT r m a -> ContT r m a
mapContT m r -> m r
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: ContT r m a -> ContT r m a
unblock = (m r -> m r) -> ContT r m a -> ContT r m a
forall k (m :: k -> *) (r :: k) a.
(m r -> m r) -> ContT r m a -> ContT r m a
mapContT m r -> m r
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance (MonadCatchIO m, Error e) => MonadCatchIO (ErrorT e m) where
m :: ErrorT e m a
m catch :: ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a
`catch` f :: e -> ErrorT e m a
f = (m (Either e a) -> m (Either e a)) -> ErrorT e m a -> ErrorT e m a
forall (m :: * -> *) e a (n :: * -> *) e' b.
(m (Either e a) -> n (Either e' b))
-> ErrorT e m a -> ErrorT e' n b
mapErrorT (\m' :: m (Either e a)
m' -> m (Either e a)
m' m (Either e a) -> (e -> m (Either e a)) -> m (Either e a)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> ErrorT e m a -> m (Either e a)
forall e (m :: * -> *) a. ErrorT e m a -> m (Either e a)
runErrorT (ErrorT e m a -> m (Either e a)) -> ErrorT e m a -> m (Either e a)
forall a b. (a -> b) -> a -> b
$ e -> ErrorT e m a
f e
e) ErrorT e m a
m
block :: ErrorT e m a -> ErrorT e m a
block = (m (Either e a) -> m (Either e a)) -> ErrorT e m a -> ErrorT e m a
forall (m :: * -> *) e a (n :: * -> *) e' b.
(m (Either e a) -> n (Either e' b))
-> ErrorT e m a -> ErrorT e' n b
mapErrorT m (Either e a) -> m (Either e a)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: ErrorT e m a -> ErrorT e m a
unblock = (m (Either e a) -> m (Either e a)) -> ErrorT e m a -> ErrorT e m a
forall (m :: * -> *) e a (n :: * -> *) e' b.
(m (Either e a) -> n (Either e' b))
-> ErrorT e m a -> ErrorT e' n b
mapErrorT m (Either e a) -> m (Either e a)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance (MonadCatchIO m) => MonadCatchIO (IdentityT m) where
m :: IdentityT m a
m catch :: IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a
`catch` f :: e -> IdentityT m a
f = (m a -> m a) -> IdentityT m a -> IdentityT m a
forall k1 k2 (m :: k1 -> *) (a :: k1) (n :: k2 -> *) (b :: k2).
(m a -> n b) -> IdentityT m a -> IdentityT n b
mapIdentityT (\m' :: m a
m' -> m a
m' m a -> (e -> m a) -> m a
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> IdentityT m a -> m a
forall k (f :: k -> *) (a :: k). IdentityT f a -> f a
runIdentityT (IdentityT m a -> m a) -> IdentityT m a -> m a
forall a b. (a -> b) -> a -> b
$ e -> IdentityT m a
f e
e) IdentityT m a
m
block :: IdentityT m a -> IdentityT m a
block = (m a -> m a) -> IdentityT m a -> IdentityT m a
forall k1 k2 (m :: k1 -> *) (a :: k1) (n :: k2 -> *) (b :: k2).
(m a -> n b) -> IdentityT m a -> IdentityT n b
mapIdentityT m a -> m a
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: IdentityT m a -> IdentityT m a
unblock = (m a -> m a) -> IdentityT m a -> IdentityT m a
forall k1 k2 (m :: k1 -> *) (a :: k1) (n :: k2 -> *) (b :: k2).
(m a -> n b) -> IdentityT m a -> IdentityT n b
mapIdentityT m a -> m a
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance MonadCatchIO m => MonadCatchIO (ListT m) where
m :: ListT m a
m catch :: ListT m a -> (e -> ListT m a) -> ListT m a
`catch` f :: e -> ListT m a
f = m [a] -> ListT m a
forall (m :: * -> *) a. m [a] -> ListT m a
ListT (m [a] -> ListT m a) -> m [a] -> ListT m a
forall a b. (a -> b) -> a -> b
$ ListT m a -> m [a]
forall (m :: * -> *) a. ListT m a -> m [a]
runListT ListT m a
m m [a] -> (e -> m [a]) -> m [a]
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> ListT m a -> m [a]
forall (m :: * -> *) a. ListT m a -> m [a]
runListT (e -> ListT m a
f e
e)
block :: ListT m a -> ListT m a
block = (m [a] -> m [a]) -> ListT m a -> ListT m a
forall (m :: * -> *) a (n :: * -> *) b.
(m [a] -> n [b]) -> ListT m a -> ListT n b
mapListT m [a] -> m [a]
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: ListT m a -> ListT m a
unblock = (m [a] -> m [a]) -> ListT m a -> ListT m a
forall (m :: * -> *) a (n :: * -> *) b.
(m [a] -> n [b]) -> ListT m a -> ListT n b
mapListT m [a] -> m [a]
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance (MonadCatchIO m) => MonadCatchIO (MaybeT m) where
m :: MaybeT m a
m catch :: MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a
`catch` f :: e -> MaybeT m a
f = (m (Maybe a) -> m (Maybe a)) -> MaybeT m a -> MaybeT m a
forall (m :: * -> *) a (n :: * -> *) b.
(m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
mapMaybeT (\m' :: m (Maybe a)
m' -> m (Maybe a)
m' m (Maybe a) -> (e -> m (Maybe a)) -> m (Maybe a)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> MaybeT m a -> m (Maybe a)
forall (m :: * -> *) a. MaybeT m a -> m (Maybe a)
runMaybeT (MaybeT m a -> m (Maybe a)) -> MaybeT m a -> m (Maybe a)
forall a b. (a -> b) -> a -> b
$ e -> MaybeT m a
f e
e) MaybeT m a
m
block :: MaybeT m a -> MaybeT m a
block = (m (Maybe a) -> m (Maybe a)) -> MaybeT m a -> MaybeT m a
forall (m :: * -> *) a (n :: * -> *) b.
(m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
mapMaybeT m (Maybe a) -> m (Maybe a)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: MaybeT m a -> MaybeT m a
unblock = (m (Maybe a) -> m (Maybe a)) -> MaybeT m a -> MaybeT m a
forall (m :: * -> *) a (n :: * -> *) b.
(m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
mapMaybeT m (Maybe a) -> m (Maybe a)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance (Monoid w, MonadCatchIO m) => MonadCatchIO (RWST r w s m) where
m :: RWST r w s m a
m catch :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a
`catch` f :: e -> RWST r w s m a
f = (r -> s -> m (a, s, w)) -> RWST r w s m a
forall r w s (m :: * -> *) a.
(r -> s -> m (a, s, w)) -> RWST r w s m a
RWST ((r -> s -> m (a, s, w)) -> RWST r w s m a)
-> (r -> s -> m (a, s, w)) -> RWST r w s m a
forall a b. (a -> b) -> a -> b
$ \r :: r
r s :: s
s -> RWST r w s m a -> r -> s -> m (a, s, w)
forall r w s (m :: * -> *) a.
RWST r w s m a -> r -> s -> m (a, s, w)
runRWST RWST r w s m a
m r
r s
s m (a, s, w) -> (e -> m (a, s, w)) -> m (a, s, w)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> RWST r w s m a -> r -> s -> m (a, s, w)
forall r w s (m :: * -> *) a.
RWST r w s m a -> r -> s -> m (a, s, w)
runRWST (e -> RWST r w s m a
f e
e) r
r s
s
block :: RWST r w s m a -> RWST r w s m a
block = (m (a, s, w) -> m (a, s, w)) -> RWST r w s m a -> RWST r w s m a
forall (m :: * -> *) a s w (n :: * -> *) b w' r.
(m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
mapRWST m (a, s, w) -> m (a, s, w)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: RWST r w s m a -> RWST r w s m a
unblock = (m (a, s, w) -> m (a, s, w)) -> RWST r w s m a -> RWST r w s m a
forall (m :: * -> *) a s w (n :: * -> *) b w' r.
(m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
mapRWST m (a, s, w) -> m (a, s, w)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance (Monoid w, MonadCatchIO m) => MonadCatchIO (Strict.RWST r w s m) where
m :: RWST r w s m a
m catch :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a
`catch` f :: e -> RWST r w s m a
f = (r -> s -> m (a, s, w)) -> RWST r w s m a
forall r w s (m :: * -> *) a.
(r -> s -> m (a, s, w)) -> RWST r w s m a
Strict.RWST ((r -> s -> m (a, s, w)) -> RWST r w s m a)
-> (r -> s -> m (a, s, w)) -> RWST r w s m a
forall a b. (a -> b) -> a -> b
$ \r :: r
r s :: s
s -> RWST r w s m a -> r -> s -> m (a, s, w)
forall r w s (m :: * -> *) a.
RWST r w s m a -> r -> s -> m (a, s, w)
Strict.runRWST RWST r w s m a
m r
r s
s m (a, s, w) -> (e -> m (a, s, w)) -> m (a, s, w)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> RWST r w s m a -> r -> s -> m (a, s, w)
forall r w s (m :: * -> *) a.
RWST r w s m a -> r -> s -> m (a, s, w)
Strict.runRWST (e -> RWST r w s m a
f e
e) r
r s
s
block :: RWST r w s m a -> RWST r w s m a
block = (m (a, s, w) -> m (a, s, w)) -> RWST r w s m a -> RWST r w s m a
forall (m :: * -> *) a s w (n :: * -> *) b w' r.
(m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
Strict.mapRWST m (a, s, w) -> m (a, s, w)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: RWST r w s m a -> RWST r w s m a
unblock = (m (a, s, w) -> m (a, s, w)) -> RWST r w s m a -> RWST r w s m a
forall (m :: * -> *) a s w (n :: * -> *) b w' r.
(m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b
Strict.mapRWST m (a, s, w) -> m (a, s, w)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance MonadCatchIO m => MonadCatchIO (ReaderT r m) where
m :: ReaderT r m a
m catch :: ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a
`catch` f :: e -> ReaderT r m a
f = (r -> m a) -> ReaderT r m a
forall r (m :: * -> *) a. (r -> m a) -> ReaderT r m a
ReaderT ((r -> m a) -> ReaderT r m a) -> (r -> m a) -> ReaderT r m a
forall a b. (a -> b) -> a -> b
$ \r :: r
r -> ReaderT r m a -> r -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT ReaderT r m a
m r
r m a -> (e -> m a) -> m a
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> ReaderT r m a -> r -> m a
forall r (m :: * -> *) a. ReaderT r m a -> r -> m a
runReaderT (e -> ReaderT r m a
f e
e) r
r
block :: ReaderT r m a -> ReaderT r m a
block = (m a -> m a) -> ReaderT r m a -> ReaderT r m a
forall (m :: * -> *) a (n :: * -> *) b r.
(m a -> n b) -> ReaderT r m a -> ReaderT r n b
mapReaderT m a -> m a
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: ReaderT r m a -> ReaderT r m a
unblock = (m a -> m a) -> ReaderT r m a -> ReaderT r m a
forall (m :: * -> *) a (n :: * -> *) b r.
(m a -> n b) -> ReaderT r m a -> ReaderT r n b
mapReaderT m a -> m a
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance MonadCatchIO m => MonadCatchIO (StateT s m) where
m :: StateT s m a
m catch :: StateT s m a -> (e -> StateT s m a) -> StateT s m a
`catch` f :: e -> StateT s m a
f = (s -> m (a, s)) -> StateT s m a
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
StateT ((s -> m (a, s)) -> StateT s m a)
-> (s -> m (a, s)) -> StateT s m a
forall a b. (a -> b) -> a -> b
$ \s :: s
s -> StateT s m a -> s -> m (a, s)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT StateT s m a
m s
s m (a, s) -> (e -> m (a, s)) -> m (a, s)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> StateT s m a -> s -> m (a, s)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
runStateT (e -> StateT s m a
f e
e) s
s
block :: StateT s m a -> StateT s m a
block = (m (a, s) -> m (a, s)) -> StateT s m a -> StateT s m a
forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
mapStateT m (a, s) -> m (a, s)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: StateT s m a -> StateT s m a
unblock = (m (a, s) -> m (a, s)) -> StateT s m a -> StateT s m a
forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
mapStateT m (a, s) -> m (a, s)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance MonadCatchIO m => MonadCatchIO (Strict.StateT s m) where
m :: StateT s m a
m catch :: StateT s m a -> (e -> StateT s m a) -> StateT s m a
`catch` f :: e -> StateT s m a
f = (s -> m (a, s)) -> StateT s m a
forall s (m :: * -> *) a. (s -> m (a, s)) -> StateT s m a
Strict.StateT ((s -> m (a, s)) -> StateT s m a)
-> (s -> m (a, s)) -> StateT s m a
forall a b. (a -> b) -> a -> b
$ \s :: s
s -> StateT s m a -> s -> m (a, s)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
Strict.runStateT StateT s m a
m s
s m (a, s) -> (e -> m (a, s)) -> m (a, s)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> StateT s m a -> s -> m (a, s)
forall s (m :: * -> *) a. StateT s m a -> s -> m (a, s)
Strict.runStateT (e -> StateT s m a
f e
e) s
s
block :: StateT s m a -> StateT s m a
block = (m (a, s) -> m (a, s)) -> StateT s m a -> StateT s m a
forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
Strict.mapStateT m (a, s) -> m (a, s)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: StateT s m a -> StateT s m a
unblock = (m (a, s) -> m (a, s)) -> StateT s m a -> StateT s m a
forall (m :: * -> *) a s (n :: * -> *) b.
(m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b
Strict.mapStateT m (a, s) -> m (a, s)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance (Monoid w, MonadCatchIO m) => MonadCatchIO (WriterT w m) where
m :: WriterT w m a
m catch :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a
`catch` f :: e -> WriterT w m a
f = (m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a
forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
mapWriterT (\m' :: m (a, w)
m' -> m (a, w)
m' m (a, w) -> (e -> m (a, w)) -> m (a, w)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> WriterT w m a -> m (a, w)
forall w (m :: * -> *) a. WriterT w m a -> m (a, w)
runWriterT (WriterT w m a -> m (a, w)) -> WriterT w m a -> m (a, w)
forall a b. (a -> b) -> a -> b
$ e -> WriterT w m a
f e
e) WriterT w m a
m
block :: WriterT w m a -> WriterT w m a
block = (m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a
forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
mapWriterT m (a, w) -> m (a, w)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: WriterT w m a -> WriterT w m a
unblock = (m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a
forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
mapWriterT m (a, w) -> m (a, w)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
instance (Monoid w, MonadCatchIO m) => MonadCatchIO (Strict.WriterT w m) where
m :: WriterT w m a
m catch :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a
`catch` f :: e -> WriterT w m a
f = (m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a
forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Strict.mapWriterT (\m' :: m (a, w)
m' -> m (a, w)
m' m (a, w) -> (e -> m (a, w)) -> m (a, w)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` \e :: e
e -> WriterT w m a -> m (a, w)
forall w (m :: * -> *) a. WriterT w m a -> m (a, w)
Strict.runWriterT (WriterT w m a -> m (a, w)) -> WriterT w m a -> m (a, w)
forall a b. (a -> b) -> a -> b
$ e -> WriterT w m a
f e
e) WriterT w m a
m
block :: WriterT w m a -> WriterT w m a
block = (m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a
forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Strict.mapWriterT m (a, w) -> m (a, w)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block
unblock :: WriterT w m a -> WriterT w m a
unblock = (m (a, w) -> m (a, w)) -> WriterT w m a -> WriterT w m a
forall (m :: * -> *) a w (n :: * -> *) b w'.
(m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b
Strict.mapWriterT m (a, w) -> m (a, w)
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock
throw :: (MonadIO m, E.Exception e) => e -> m a
throw :: e -> m a
throw = IO a -> m a
forall (m :: * -> *) a. MonadIO m => IO a -> m a
liftIO (IO a -> m a) -> (e -> IO a) -> e -> m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> IO a
forall e a. Exception e => e -> IO a
E.throwIO
try :: (MonadCatchIO m, Functor m, E.Exception e) => m a -> m (Either e a)
try :: m a -> m (Either e a)
try a :: m a
a = m (Either e a) -> (e -> m (Either e a)) -> m (Either e a)
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
catch (a -> Either e a
forall a b. b -> Either a b
Right (a -> Either e a) -> m a -> m (Either e a)
forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> m a
a) (Either e a -> m (Either e a)
forall (m :: * -> *) a. Monad m => a -> m a
return (Either e a -> m (Either e a))
-> (e -> Either e a) -> e -> m (Either e a)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> Either e a
forall a b. a -> Either a b
Left)
tryJust :: (MonadCatchIO m, Functor m, E.Exception e)
=> (e -> Maybe b) -> m a -> m (Either b a)
tryJust :: (e -> Maybe b) -> m a -> m (Either b a)
tryJust p :: e -> Maybe b
p a :: m a
a = do
Either e a
r <- m a -> m (Either e a)
forall (m :: * -> *) e a.
(MonadCatchIO m, Functor m, Exception e) =>
m a -> m (Either e a)
try m a
a
case Either e a
r of
Right v :: a
v -> Either b a -> m (Either b a)
forall (m :: * -> *) a. Monad m => a -> m a
return (a -> Either b a
forall a b. b -> Either a b
Right a
v)
Left e :: e
e -> case e -> Maybe b
p e
e of
Nothing -> e -> m (Either b a)
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throw e
e m (Either b a) -> m (Either b a) -> m (Either b a)
forall a. a -> a -> a
`asTypeOf` Either b a -> m (Either b a)
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> Either b a
forall a b. a -> Either a b
Left b
forall a. HasCallStack => a
undefined)
Just b :: b
b -> Either b a -> m (Either b a)
forall (m :: * -> *) a. Monad m => a -> m a
return (b -> Either b a
forall a b. a -> Either a b
Left b
b)
data Handler m a = forall e . E.Exception e => Handler (e -> m a)
catches :: MonadCatchIO m => m a -> [Handler m a] -> m a
catches :: m a -> [Handler m a] -> m a
catches a :: m a
a handlers :: [Handler m a]
handlers = m a
a m a -> (SomeException -> m a) -> m a
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` SomeException -> m a
handler where
handler :: SomeException -> m a
handler e :: SomeException
e = (Handler m a -> m a -> m a) -> m a -> [Handler m a] -> m a
forall (t :: * -> *) a b.
Foldable t =>
(a -> b -> b) -> b -> t a -> b
foldr Handler m a -> m a -> m a
forall (m :: * -> *) a. Handler m a -> m a -> m a
tryH (SomeException -> m a
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throw SomeException
e) [Handler m a]
handlers where
tryH :: Handler m a -> m a -> m a
tryH (Handler h :: e -> m a
h) res :: m a
res = m a -> (e -> m a) -> Maybe e -> m a
forall b a. b -> (a -> b) -> Maybe a -> b
maybe m a
res e -> m a
h (Maybe e -> m a) -> Maybe e -> m a
forall a b. (a -> b) -> a -> b
$ SomeException -> Maybe e
forall e. Exception e => SomeException -> Maybe e
E.fromException SomeException
e
bracket :: MonadCatchIO m => m a -> (a -> m b) -> (a -> m c) -> m c
bracket :: m a -> (a -> m b) -> (a -> m c) -> m c
bracket before :: m a
before after :: a -> m b
after thing :: a -> m c
thing = m c -> m c
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block (m c -> m c) -> m c -> m c
forall a b. (a -> b) -> a -> b
$ do
a
a <- m a
before
c
r <- m c -> m c
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock (a -> m c
thing a
a) m c -> m b -> m c
forall (m :: * -> *) a b. MonadCatchIO m => m a -> m b -> m a
`onException` a -> m b
after a
a
b
_ <- a -> m b
after a
a
c -> m c
forall (m :: * -> *) a. Monad m => a -> m a
return c
r
onException :: MonadCatchIO m => m a -> m b -> m a
onException :: m a -> m b -> m a
onException a :: m a
a onEx :: m b
onEx = m a
a m a -> (SomeException -> m a) -> m a
forall (m :: * -> *) e a.
(MonadCatchIO m, Exception e) =>
m a -> (e -> m a) -> m a
`catch` (\ (SomeException
e :: E.SomeException) -> m b
onEx m b -> m a -> m a
forall (m :: * -> *) a b. Monad m => m a -> m b -> m b
>> SomeException -> m a
forall (m :: * -> *) e a. (MonadIO m, Exception e) => e -> m a
throw SomeException
e)
bracket_ :: MonadCatchIO m
=> m a
-> m b
-> m c
-> m c
bracket_ :: m a -> m b -> m c -> m c
bracket_ before :: m a
before after :: m b
after thing :: m c
thing = m c -> m c
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block (m c -> m c) -> m c -> m c
forall a b. (a -> b) -> a -> b
$ do
a
_ <- m a
before
c
r <- m c -> m c
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock m c
thing m c -> m b -> m c
forall (m :: * -> *) a b. MonadCatchIO m => m a -> m b -> m a
`onException` m b
after
b
_ <- m b
after
c -> m c
forall (m :: * -> *) a. Monad m => a -> m a
return c
r
finally :: MonadCatchIO m
=> m a
-> m b
-> m a
thing :: m a
thing finally :: m a -> m b -> m a
`finally` after :: m b
after = m a -> m a
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block (m a -> m a) -> m a -> m a
forall a b. (a -> b) -> a -> b
$ do
a
r <- m a -> m a
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock m a
thing m a -> m b -> m a
forall (m :: * -> *) a b. MonadCatchIO m => m a -> m b -> m a
`onException` m b
after
b
_ <- m b
after
a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return a
r
bracketOnError :: MonadCatchIO m
=> m a
-> (a -> m b)
-> (a -> m c)
-> m c
bracketOnError :: m a -> (a -> m b) -> (a -> m c) -> m c
bracketOnError before :: m a
before after :: a -> m b
after thing :: a -> m c
thing = m c -> m c
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
block (m c -> m c) -> m c -> m c
forall a b. (a -> b) -> a -> b
$ do
a
a <- m a
before
m c -> m c
forall (m :: * -> *) a. MonadCatchIO m => m a -> m a
unblock (a -> m c
thing a
a) m c -> m b -> m c
forall (m :: * -> *) a b. MonadCatchIO m => m a -> m b -> m a
`onException` a -> m b
after a
a