packages feed

exceptions 0.8.0.2 → 0.8.1

raw patch · 5 files changed

+15/−4 lines, 5 filesdep +template-haskelldep ~transformersPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: template-haskell

Dependency ranges changed: transformers

API changes (from Hackage documentation)

- Control.Monad.Catch: instance (Error e, MonadCatch m) => MonadCatch (ErrorT e m)
- Control.Monad.Catch: instance (Error e, MonadThrow m) => MonadThrow (ErrorT e m)
- Control.Monad.Catch: instance (MonadCatch m, Monoid w) => MonadCatch (RWST r w s m)
- Control.Monad.Catch: instance (MonadCatch m, Monoid w) => MonadCatch (WriterT w m)
- Control.Monad.Catch: instance (MonadMask m, Monoid w) => MonadMask (RWST r w s m)
- Control.Monad.Catch: instance (MonadMask m, Monoid w) => MonadMask (WriterT w m)
- Control.Monad.Catch: instance (MonadThrow m, Monoid w) => MonadThrow (RWST r w s m)
- Control.Monad.Catch: instance (MonadThrow m, Monoid w) => MonadThrow (WriterT w m)
- Control.Monad.Catch: instance Monad m => Functor (Handler m)
- Control.Monad.Catch: instance MonadCatch IO
- Control.Monad.Catch: instance MonadCatch STM
- Control.Monad.Catch: instance MonadCatch m => MonadCatch (ExceptT e m)
- Control.Monad.Catch: instance MonadCatch m => MonadCatch (IdentityT m)
- Control.Monad.Catch: instance MonadCatch m => MonadCatch (ListT m)
- Control.Monad.Catch: instance MonadCatch m => MonadCatch (MaybeT m)
- Control.Monad.Catch: instance MonadCatch m => MonadCatch (ReaderT r m)
- Control.Monad.Catch: instance MonadCatch m => MonadCatch (StateT s m)
- Control.Monad.Catch: instance MonadMask IO
- Control.Monad.Catch: instance MonadMask m => MonadMask (IdentityT m)
- Control.Monad.Catch: instance MonadMask m => MonadMask (ReaderT r m)
- Control.Monad.Catch: instance MonadMask m => MonadMask (StateT s m)
- Control.Monad.Catch: instance MonadThrow IO
- Control.Monad.Catch: instance MonadThrow Maybe
- Control.Monad.Catch: instance MonadThrow STM
- Control.Monad.Catch: instance MonadThrow []
- Control.Monad.Catch: instance MonadThrow m => MonadThrow (ContT r m)
- Control.Monad.Catch: instance MonadThrow m => MonadThrow (ExceptT e m)
- Control.Monad.Catch: instance MonadThrow m => MonadThrow (IdentityT m)
- Control.Monad.Catch: instance MonadThrow m => MonadThrow (ListT m)
- Control.Monad.Catch: instance MonadThrow m => MonadThrow (MaybeT m)
- Control.Monad.Catch: instance MonadThrow m => MonadThrow (ReaderT r m)
- Control.Monad.Catch: instance MonadThrow m => MonadThrow (StateT s m)
- Control.Monad.Catch: instance e ~ SomeException => MonadThrow (Either e)
- Control.Monad.Catch.Pure: instance (Monad m, Traversable m) => Traversable (CatchT m)
- Control.Monad.Catch.Pure: instance Foldable m => Foldable (CatchT m)
- Control.Monad.Catch.Pure: instance Monad m => Alternative (CatchT m)
- Control.Monad.Catch.Pure: instance Monad m => Applicative (CatchT m)
- Control.Monad.Catch.Pure: instance Monad m => Functor (CatchT m)
- Control.Monad.Catch.Pure: instance Monad m => Monad (CatchT m)
- Control.Monad.Catch.Pure: instance Monad m => MonadCatch (CatchT m)
- Control.Monad.Catch.Pure: instance Monad m => MonadMask (CatchT m)
- Control.Monad.Catch.Pure: instance Monad m => MonadPlus (CatchT m)
- Control.Monad.Catch.Pure: instance Monad m => MonadThrow (CatchT m)
- Control.Monad.Catch.Pure: instance MonadFix m => MonadFix (CatchT m)
- Control.Monad.Catch.Pure: instance MonadIO m => MonadIO (CatchT m)
- Control.Monad.Catch.Pure: instance MonadRWS r w s m => MonadRWS r w s (CatchT m)
- Control.Monad.Catch.Pure: instance MonadReader e m => MonadReader e (CatchT m)
- Control.Monad.Catch.Pure: instance MonadState s m => MonadState s (CatchT m)
- Control.Monad.Catch.Pure: instance MonadTrans CatchT
- Control.Monad.Catch.Pure: instance MonadWriter w m => MonadWriter w (CatchT m)
- Control.Monad.Catch.Pure: runCatchT :: CatchT m a -> m (Either SomeException a)
+ Control.Monad.Catch: displayException :: Exception e => e -> String
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadCatch m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadCatch m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.RWS.Strict.RWST r w s m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadCatch m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Writer.Lazy.WriterT w m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadCatch m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Writer.Strict.WriterT w m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadMask m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadMask m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.RWS.Strict.RWST r w s m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadMask m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Writer.Lazy.WriterT w m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadMask m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Writer.Strict.WriterT w m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadThrow m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.RWS.Lazy.RWST r w s m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadThrow m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.RWS.Strict.RWST r w s m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadThrow m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Writer.Lazy.WriterT w m)
+ Control.Monad.Catch: instance (Control.Monad.Catch.MonadThrow m, GHC.Base.Monoid w) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Writer.Strict.WriterT w m)
+ Control.Monad.Catch: instance (Control.Monad.Trans.Error.Error e, Control.Monad.Catch.MonadCatch m) => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Error.ErrorT e m)
+ Control.Monad.Catch: instance (Control.Monad.Trans.Error.Error e, Control.Monad.Catch.MonadThrow m) => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Error.ErrorT e m)
+ Control.Monad.Catch: instance (e ~ GHC.Exception.SomeException) => Control.Monad.Catch.MonadThrow (Data.Either.Either e)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch GHC.Conc.Sync.STM
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch GHC.Types.IO
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Except.ExceptT e m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Identity.IdentityT m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.List.ListT m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Maybe.MaybeT m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.Reader.ReaderT r m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.State.Lazy.StateT s m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadCatch m => Control.Monad.Catch.MonadCatch (Control.Monad.Trans.State.Strict.StateT s m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadMask GHC.Types.IO
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Identity.IdentityT m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.Reader.ReaderT r m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.State.Lazy.StateT s m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadMask m => Control.Monad.Catch.MonadMask (Control.Monad.Trans.State.Strict.StateT s m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow GHC.Base.Maybe
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow GHC.Conc.Sync.STM
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow GHC.Types.IO
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow Language.Haskell.TH.Syntax.Q
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow []
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Cont.ContT r m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Except.ExceptT e m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Identity.IdentityT m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.List.ListT m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Maybe.MaybeT m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.Reader.ReaderT r m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.State.Lazy.StateT s m)
+ Control.Monad.Catch: instance Control.Monad.Catch.MonadThrow m => Control.Monad.Catch.MonadThrow (Control.Monad.Trans.State.Strict.StateT s m)
+ Control.Monad.Catch: instance GHC.Base.Monad m => GHC.Base.Functor (Control.Monad.Catch.Handler m)
+ Control.Monad.Catch.Pure: [runCatchT] :: CatchT m a -> m (Either SomeException a)
+ Control.Monad.Catch.Pure: instance (GHC.Base.Monad m, Data.Traversable.Traversable m) => Data.Traversable.Traversable (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance Control.Monad.RWS.Class.MonadRWS r w s m => Control.Monad.RWS.Class.MonadRWS r w s (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance Control.Monad.Reader.Class.MonadReader e m => Control.Monad.Reader.Class.MonadReader e (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance Control.Monad.State.Class.MonadState s m => Control.Monad.State.Class.MonadState s (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Catch.Pure.CatchT
+ Control.Monad.Catch.Pure: instance Control.Monad.Writer.Class.MonadWriter w m => Control.Monad.Writer.Class.MonadWriter w (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance Data.Foldable.Foldable m => Data.Foldable.Foldable (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance GHC.Base.Monad m => Control.Monad.Catch.MonadCatch (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance GHC.Base.Monad m => Control.Monad.Catch.MonadMask (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance GHC.Base.Monad m => Control.Monad.Catch.MonadThrow (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance GHC.Base.Monad m => GHC.Base.Alternative (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance GHC.Base.Monad m => GHC.Base.Applicative (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance GHC.Base.Monad m => GHC.Base.Functor (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Catch.Pure.CatchT m)
+ Control.Monad.Catch.Pure: instance GHC.Base.Monad m => GHC.Base.MonadPlus (Control.Monad.Catch.Pure.CatchT m)

Files

CHANGELOG.markdown view
@@ -1,3 +1,8 @@+0.8.1+-----+* Support for throwing in the `template-haskell` `Q` monad+* Support for `transformers` 0.5+ 0.8.0.1 ------- * Resolved warnings on GHC 7.10 and with transformers 0.4.
README.markdown view
@@ -1,7 +1,7 @@ exceptions ========== -[![Build Status](https://secure.travis-ci.org/ekmett/exceptions.png?branch=master)](http://travis-ci.org/ekmett/exceptions)+[![Hackage](https://img.shields.io/hackage/v/exceptions.svg)](https://hackage.haskell.org/package/exceptions) [![Build Status](https://secure.travis-ci.org/ekmett/exceptions.png?branch=master)](http://travis-ci.org/ekmett/exceptions)  This package provides (optionally pure) extensible exceptions that are compatible with the monad transformer library.
exceptions.cabal view
@@ -1,6 +1,6 @@ name:          exceptions category:      Control, Exceptions, Monad-version:       0.8.0.2+version:       0.8.1 cabal-version: >= 1.8 license:       BSD3 license-file:  LICENSE@@ -35,7 +35,8 @@   build-depends:     base                       >= 4.3      && < 5,     stm                        >= 2.2      && < 3,-    transformers               >= 0.2      && < 0.5,+    template-haskell           >= 2.2      && < 2.11,+    transformers               >= 0.2      && < 0.6,     transformers-compat        >= 0.3      && < 0.5,     mtl                        >= 2.0      && < 2.3 @@ -55,6 +56,7 @@   build-depends:     base,     stm,+    template-haskell,     transformers,     transformers-compat,     mtl,
src/Control/Monad/Catch.hs view
@@ -93,6 +93,8 @@ import Control.Monad.Trans.Identity import Control.Monad.Reader as Reader +import Language.Haskell.TH.Syntax (Q)+ #if __GLASGOW_HASKELL__ < 706 import Prelude hiding (catch, foldr) import Data.Foldable@@ -183,6 +185,8 @@   throwM _ = Nothing instance e ~ SomeException => MonadThrow (Either e) where   throwM = Left . toException+instance MonadThrow Q where+  throwM = fail . show  instance MonadThrow IO where   throwM = ControlException.throwIO
src/Control/Monad/Catch/Pure.hs view
@@ -105,7 +105,7 @@   (<*>) = ap  instance Monad m => Monad (CatchT m) where-  return a = CatchT (return (Right a))+  return = pure   CatchT m >>= k = CatchT $ m >>= \ea -> case ea of     Left e -> return (Left e)     Right a -> runCatchT (k a)