MonadCatchIO-transformers 0.2.1.0 → 0.2.2.0

raw patch · 2 files changed

+72/−35 lines, 2 filesPVP ok

version bump matches the API change (PVP)

API changes (from Hackage documentation)

Files

• MonadCatchIO-transformers.cabal +6/−6
• src/Control/Monad/CatchIO.hs +66/−29

@@ -1,5 +1,5 @@ Name:            MonadCatchIO-transformers-Version:         0.2.1.0+Version:         0.2.2.0 Cabal-Version:   >= 1.6 License:         PublicDomain Description:@@ -13,6 +13,10 @@ Synopsis:        Monad-transformer compatible version of the Control.Exception module Build-Type:      Simple +Source-repository head+  Type:     darcs+  Location: http://patch-tag.com/r/AriePeterson/MonadCatchIO-transformers+ Library   Build-Depends:     base == 4.*,@@ -21,8 +25,4 @@   Exposed-Modules:     Control.Monad.CatchIO   Hs-Source-Dirs:  src-  Ghc-options: -Wall-  Extensions:-    ExistentialQuantification,-    ScopedTypeVariables-+  Ghc-options:     -Wall

@@ -1,3 +1,4 @@+{-# LANGUAGE ExistentialQuantification, ScopedTypeVariables #-} module Control.Monad.CatchIO   (     MonadCatchIO(..)@@ -16,20 +17,27 @@ where  import           Prelude hiding ( catch )+import           Control.Applicative                          ((<$>))+import qualified Control.Exception.Extensible      as E -import           Control.Applicative        ((<$>))-import qualified Control.Exception.Extensible as E+import           Control.Monad.IO.Class                       (MonadIO,liftIO) -import           Control.Monad.IO.Class           (MonadIO,liftIO)  -import           Control.Monad.Trans.Error        (ErrorT          ,runErrorT ,mapErrorT ,Error)-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 StrictState-import           Control.Monad.Trans.Writer       (WriterT(WriterT),runWriterT,mapWriterT)-import           Control.Monad.Trans.RWS          (RWST(RWST)      ,runRWST   ,mapRWST   )-import           Data.Monoid                      (Monoid)+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) + class MonadIO m => MonadCatchIO m where   -- | Generalized version of 'E.catch'   catch   :: E.Exception e => m a -> (e -> m a) -> m a@@ -46,6 +54,41 @@   block   = E.block   unblock = E.unblock +instance MonadCatchIO m => MonadCatchIO (ContT r m) where+  m `catch` f = ContT $ \c -> runContT m c `catch` \e -> runContT (f e) c+  block       = mapContT block+  unblock     = mapContT unblock++instance (MonadCatchIO m, Error e) => MonadCatchIO (ErrorT e m) where+  m `catch` f = mapErrorT (\m' -> m' `catch` \e -> runErrorT $ f e) m+  block       = mapErrorT block+  unblock     = mapErrorT unblock++instance (MonadCatchIO m) => MonadCatchIO (IdentityT m) where+  m `catch` f = mapIdentityT (\m' -> m' `catch` \e -> runIdentityT $ f e) m+  block       = mapIdentityT block+  unblock     = mapIdentityT unblock++instance MonadCatchIO m => MonadCatchIO (ListT m) where+  m `catch` f = ListT $ runListT m `catch` \e -> runListT (f e)+  block       = mapListT block+  unblock     = mapListT unblock++instance (MonadCatchIO m) => MonadCatchIO (MaybeT m) where+  m `catch` f = mapMaybeT (\m' -> m' `catch` \e -> runMaybeT $ f e) m+  block       = mapMaybeT block+  unblock     = mapMaybeT unblock++instance (Monoid w, MonadCatchIO m) => MonadCatchIO (RWST r w s m) where+  m `catch` f = RWST $ \r s -> runRWST m r s `catch` \e -> runRWST (f e) r s+  block       = mapRWST block+  unblock     = mapRWST unblock++instance (Monoid w, MonadCatchIO m) => MonadCatchIO (Strict.RWST r w s m) where+  m `catch` f = Strict.RWST $ \r s -> Strict.runRWST m r s `catch` \e -> Strict.runRWST (f e) r s+  block       = Strict.mapRWST block+  unblock     = Strict.mapRWST unblock+ instance MonadCatchIO m => MonadCatchIO (ReaderT r m) where   m `catch` f = ReaderT $ \r -> runReaderT m r `catch` \e -> runReaderT (f e) r   block       = mapReaderT block@@ -56,26 +99,20 @@   block       = mapStateT block   unblock     = mapStateT unblock -instance MonadCatchIO m => MonadCatchIO (StrictState.StateT s m) where-  m `catch` f = StrictState.StateT $ \s -> StrictState.runStateT m s `catch` \e -> StrictState.runStateT (f e) s-  block       = StrictState.mapStateT block-  unblock     = StrictState.mapStateT unblock--instance (MonadCatchIO m, Error e) => MonadCatchIO (ErrorT e m) where-  m `catch` f = mapErrorT (\m' -> m' `catch` \e -> runErrorT $ f e) m-  block       = mapErrorT block-  unblock     = mapErrorT unblock+instance MonadCatchIO m => MonadCatchIO (Strict.StateT s m) where+  m `catch` f = Strict.StateT $ \s -> Strict.runStateT m s `catch` \e -> Strict.runStateT (f e) s+  block       = Strict.mapStateT block+  unblock     = Strict.mapStateT unblock  instance (Monoid w, MonadCatchIO m) => MonadCatchIO (WriterT w m) where-  m `catch` f = WriterT $ runWriterT m `catch` \e -> runWriterT $ f e+  m `catch` f = mapWriterT (\m' -> m' `catch` \e -> runWriterT $ f e) m   block       = mapWriterT block   unblock     = mapWriterT unblock -instance (Monoid w, MonadCatchIO m) => MonadCatchIO (RWST r w s m) where-  m `catch` f = RWST $ \r s -> runRWST m r s `catch` \e -> runRWST (f e) r s-  block       = mapRWST block-  unblock     = mapRWST unblock-+instance (Monoid w, MonadCatchIO m) => MonadCatchIO (Strict.WriterT w m) where+  m `catch` f = Strict.mapWriterT (\m' -> m' `catch` \e -> Strict.runWriterT $ f e) m+  block       = Strict.mapWriterT block+  unblock     = Strict.mapWriterT unblock  -- | Generalized version of 'E.throwIO' throw :: (MonadIO m, E.Exception e) => e -> m a@@ -110,7 +147,7 @@ bracket before after thing = block $ do   a <- before   r <- unblock (thing a) `onException` after a-  after a+  _ <- after a   return r  -- | Generalized version of 'E.onException'@@ -125,9 +162,9 @@          -> m c  -- ^ computation to run in-between          -> m c  -- returns the value from the in-between computation bracket_ before after thing = block $ do-  before+  _ <- before   r <- unblock thing `onException` after-  after+  _ <- after   return r  -- | A specialised variant of 'bracket' with just a computation to run@@ -139,7 +176,7 @@         -> m a -- returns the value from the first computation thing `finally` after = block $ do   r <- unblock thing `onException` after-  after+  _ <- after   return r  -- | Like 'bracket', but only performs the final action if there was an