{-# OPTIONS_GHC -fno-warn-deprecations #-} module Exception ( module Control.Exception, module Exception ) where import Prelude hiding (catch) import Control.Exception catchIO :: IO a -> (IOException -> IO a) -> IO a catchIO = catch handleIO :: (IOException -> IO a) -> IO a -> IO a handleIO = flip catchIO tryIO :: IO a -> IO (Either IOException a) tryIO = try -- | A monad that can catch exceptions. A minimal definition -- requires a definition of 'gcatch'. -- -- Implementations on top of 'IO' should implement 'gblock' and 'gunblock' to -- eventually call the primitives 'Control.Exception.block' and -- 'Control.Exception.unblock' respectively. These are used for -- implementations that support asynchronous exceptions. The default -- implementations of 'gbracket' and 'gfinally' use 'gblock' and 'gunblock' -- thus rarely require overriding. -- class Monad m => ExceptionMonad m where -- | Generalised version of 'Control.Exception.catch', allowing an arbitrary -- exception handling monad instead of just 'IO'. gcatch :: Exception e => m a -> (e -> m a) -> m a -- | Generalised version of 'Control.Exception.mask_', allowing an arbitrary -- exception handling monad instead of just 'IO'. gmask :: ((m a -> m a) -> m b) -> m b -- | Generalised version of 'Control.Exception.bracket', allowing an arbitrary -- exception handling monad instead of just 'IO'. gbracket :: m a -> (a -> m b) -> (a -> m c) -> m c -- | Generalised version of 'Control.Exception.finally', allowing an arbitrary -- exception handling monad instead of just 'IO'. gfinally :: m a -> m b -> m a -- | DEPRECATED, here for backwards compatibilty. Instances can -- define either 'gmask', or both 'block' and 'unblock'. gblock :: m a -> m a -- | DEPRECATED, here for backwards compatibilty Instances can -- define either 'gmask', or both 'block' and 'unblock'. gunblock :: m a -> m a -- XXX we're keeping these two methods for the time being because we -- have to interact with Haskeline's MonadException class which -- still has block/unblock; see GhciMonad.hs. gmask f = gblock (f gunblock) gblock f = gmask (\_ -> f) gunblock f = f -- XXX wrong; better override this if you need it gbracket before after thing = gmask $ \restore -> do a <- before r <- restore (thing a) `gonException` after a _ <- after a return r a `gfinally` sequel = gmask $ \restore -> do r <- restore a `gonException` sequel _ <- sequel return r #if __GLASGOW_HASKELL__ < 613 instance ExceptionMonad IO where gcatch = catch gmask f = block $ f unblock gblock = block gunblock = unblock #else instance ExceptionMonad IO where gcatch = catch gmask f = mask (\x -> f x) gblock = block gunblock = unblock #endif gtry :: (ExceptionMonad m, Exception e) => m a -> m (Either e a) gtry act = gcatch (act >>= \a -> return (Right a)) (\e -> return (Left e)) -- | Generalised version of 'Control.Exception.handle', allowing an arbitrary -- exception handling monad instead of just 'IO'. ghandle :: (ExceptionMonad m, Exception e) => (e -> m a) -> m a -> m a ghandle = flip gcatch -- | Always executes the first argument. If this throws an exception the -- second argument is executed and the exception is raised again. gonException :: (ExceptionMonad m) => m a -> m b -> m a gonException ioA cleanup = ioA `gcatch` \e -> do _ <- cleanup throw (e :: SomeException)