module Control.Exception.Peel (
module Control.Exception.Extensible,
throwIO, ioError,
catch, catches, Handler(..), catchJust,
handle, handleJust,
try, tryJust,
evaluate,
block, unblock,
bracket, bracket_, bracketOnError,
finally, onException,
) where
import Prelude hiding (catch, ioError)
import Control.Monad
import Control.Monad.IO.Class
import Control.Monad.IO.Peel
import Control.Exception.Extensible hiding (
throwIO, ioError,
catch, catches, Handler(..), catchJust,
handle, handleJust,
try, tryJust,
evaluate,
block, unblock,
bracket, bracket_, bracketOnError,
finally, onException,
)
import qualified Control.Exception.Extensible as E
throwIO :: (MonadIO m, Exception e) => e -> m a
throwIO = liftIO . E.throwIO
ioError :: MonadIO m => IOError -> m a
ioError = liftIO . E.ioError
catch :: (MonadPeelIO m, Exception e) =>
m a
-> (e -> m a)
-> m a
catch a handler = do
k <- peelIO
join $ liftIO $ E.catch (k a) (\e -> k $ handler e)
catchJust :: (MonadPeelIO m, Exception e) =>
(e -> Maybe b)
-> m a
-> (b -> m a)
-> m a
catchJust p a handler = do
k <- peelIO
join $ liftIO $ E.catchJust p (k a) (\e -> k (handler e))
catches :: MonadPeelIO m => m a -> [Handler m a] -> m a
catches a handlers = do
k <- peelIO
join $ liftIO $ E.catches (k a) [E.Handler $ \e -> k $ handler e |
Handler handler <- handlers]
data Handler m a = forall e. Exception e => Handler (e -> m a)
handle :: (MonadPeelIO m, Exception e) => (e -> m a) -> m a -> m a
handle handler a = do
k <- peelIO
join $ liftIO $ E.handle (\e -> k (handler e)) (k a)
handleJust :: (MonadPeelIO m, Exception e) =>
(e -> Maybe b) -> (b -> m a) -> m a -> m a
handleJust p handler a = do
k <- peelIO
join $ liftIO $ E.handleJust p (\e -> k (handler e)) (k a)
sequenceEither :: Monad m => Either e (m a) -> m (Either e a)
sequenceEither (Left e) = return $ Left e
sequenceEither (Right m) = liftM Right m
try :: (MonadPeelIO m, Exception e) => m a -> m (Either e a)
try = liftIOOp_ (liftM sequenceEither . E.try)
tryJust :: (MonadPeelIO m, Exception e) =>
(e -> Maybe b) -> m a -> m (Either b a)
tryJust p = liftIOOp_ (liftM sequenceEither . E.tryJust p)
evaluate :: MonadIO m => a -> m a
evaluate = liftIO . E.evaluate
block :: MonadPeelIO m => m a -> m a
block = liftIOOp_ E.block
unblock :: MonadPeelIO m => m a -> m a
unblock = liftIOOp_ E.unblock
bracket :: MonadPeelIO m =>
m a
-> (a -> m b)
-> (a -> m c)
-> m c
bracket before after thing = do
k <- peelIO
k' <- peelIO
k'' <- peelIO
join $ liftIO $
E.bracket (k before) (\x -> k' $ x >>= after) (\x -> k'' $ x >>= thing)
bracket_ :: MonadPeelIO m => m a -> m b -> m c -> m c
bracket_ before after thing = do
k <- peelIO
k' <- peelIO
k'' <- peelIO
join $ liftIO $ E.bracket_ (k before) (k' after) (k'' thing)
bracketOnError :: MonadPeelIO m =>
m a
-> (a -> m b)
-> (a -> m c)
-> m c
bracketOnError before after thing = do
k <- peelIO
k' <- peelIO
k'' <- peelIO
join $ liftIO $
E.bracket (k before) (\x -> k' $ x >>= after) (\x -> k'' $ x >>= thing)
finally :: MonadPeelIO m =>
m a
-> m b
-> m a
finally a sequel = do
k <- peelIO
k' <- peelIO
join $ liftIO $ E.finally (k a) (k' sequel)
onException :: MonadPeelIO m => m a -> m b -> m a
onException m what = do
k <- peelIO
k' <- peelIO
join $ liftIO $ E.onException (k m) (k' what)