control-monad-exception 0.8.0.4 → 0.9.0

raw patch · 3 files changed

+28/−3 lines, 3 filesdep +safe-failuredep ~failurePVP ok

version bump matches the API change (PVP)

Dependencies added: safe-failure

Dependency ranges changed: failure

API changes (from Hackage documentation)

- Control.Monad.Exception: class (Monad f, Applicative f, Failure e f) => MonadFailure e f :: (* -> *)

- Control.Monad.Exception.Base: instance (Eq a) => Eq (Identity a)

- Control.Monad.Exception.Base: instance (Exception e) => Throws e AnyException

- Control.Monad.Exception.Base: instance (Monad m) => Applicative (EMT l m)

- Control.Monad.Exception.Base: instance (Monad m) => Functor (EMT l m)

- Control.Monad.Exception.Base: instance (Monad m) => Monad (EMT l m)

- Control.Monad.Exception.Base: instance (Monad m) => MonadLoc (EMT l m)

- Control.Monad.Exception.Base: instance (MonadFix m) => MonadFix (EMT l m)

- Control.Monad.Exception.Base: instance (Ord a) => Ord (Identity a)

- Control.Monad.Exception.Base: instance (Show a) => Show (Identity a)

- Control.Monad.Exception.Base: instance (Throws MonadZeroException l) => MonadPlus (EM l)

- Control.Monad.Exception.Base: instance (UncaughtException e) => Throws e NoExceptions

- Control.Monad.Exception.Catch: instance [overlap ok] (Exception e) => MonadCatch e IO IO

- Control.Monad.Exception.Throws: instance [overlap ok] (Exception e) => Throws e (Caught SomeException l)

- Control.Monad.Exception.Throws: instance [overlap ok] (Exception e) => Throws e (Caught e l)

- Control.Monad.Exception.Throws: instance [overlap ok] (Throws e l) => Throws e (Caught e' l)

+ Control.Monad.Exception.Base: instance Eq a => Eq (Identity a)

+ Control.Monad.Exception.Base: instance Exception e => Throws e AnyException

+ Control.Monad.Exception.Base: instance Monad m => Applicative (EMT l m)

+ Control.Monad.Exception.Base: instance Monad m => Functor (EMT l m)

+ Control.Monad.Exception.Base: instance Monad m => Monad (EMT l m)

+ Control.Monad.Exception.Base: instance Monad m => MonadLoc (EMT l m)

+ Control.Monad.Exception.Base: instance MonadFix m => MonadFix (EMT l m)

+ Control.Monad.Exception.Base: instance Ord a => Ord (Identity a)

+ Control.Monad.Exception.Base: instance Show a => Show (Identity a)

+ Control.Monad.Exception.Base: instance Throws MonadZeroException l => MonadPlus (EM l)

+ Control.Monad.Exception.Base: instance UncaughtException e => Throws e NoExceptions

+ Control.Monad.Exception.Catch: instance [overlap ok] Exception e => MonadCatch e IO IO

+ Control.Monad.Exception.Instances: instance (Typeable a, Show a) => Throws (LookupFailure a) (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws Foldl1Failure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws Foldr1Failure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws FromJustFailure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws HeadFailure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws IndexFailure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws InitFailure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws LastFailure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws MaximumFailure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws MinimumFailure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws ReadFailure (Caught SafeException l)

+ Control.Monad.Exception.Instances: instance Throws TailFailure (Caught SafeException l)

+ Control.Monad.Exception.Throws: instance [overlap ok] Exception e => Throws e (Caught SomeException l)

+ Control.Monad.Exception.Throws: instance [overlap ok] Exception e => Throws e (Caught e l)

+ Control.Monad.Exception.Throws: instance [overlap ok] Throws e l => Throws e (Caught e' l)

- Control.Monad.Exception: bracket :: (Monad m) => EMT l m a -> (a -> EMT l m b) -> (a -> EMT l m c) -> EMT l m c

+ Control.Monad.Exception: bracket :: Monad m => EMT l m a -> (a -> EMT l m b) -> (a -> EMT l m c) -> EMT l m c

- Control.Monad.Exception: class Failure e f :: (* -> *)

+ Control.Monad.Exception: class Monad f => Failure e f :: (* -> *)

- Control.Monad.Exception: class (Monad m) => MonadLoc m :: (* -> *)

+ Control.Monad.Exception: class Monad m => MonadLoc m :: (* -> *)

- Control.Monad.Exception: class (Exception e) => Throws e l

+ Control.Monad.Exception: class Exception e => Throws e l

- Control.Monad.Exception: class (Exception e) => UncaughtException e

+ Control.Monad.Exception: class Exception e => UncaughtException e

- Control.Monad.Exception: class (Failure e f) => WrapFailure e f :: (* -> *)

+ Control.Monad.Exception: class Failure e f => WrapFailure e f :: (* -> *)

- Control.Monad.Exception: failure :: (Failure e f) => e -> f v

+ Control.Monad.Exception: failure :: Failure e f => e -> f v

- Control.Monad.Exception: finally :: (Monad m) => EMT l m a -> EMT l m b -> EMT l m a

+ Control.Monad.Exception: finally :: Monad m => EMT l m a -> EMT l m b -> EMT l m a

- Control.Monad.Exception: fromException :: (Exception e) => SomeException -> Maybe e

+ Control.Monad.Exception: fromException :: Exception e => SomeException -> Maybe e

- Control.Monad.Exception: mplusDefault :: (Monad m) => EMT l m a -> EMT l m a -> EMT l m a

+ Control.Monad.Exception: mplusDefault :: Monad m => EMT l m a -> EMT l m a -> EMT l m a

- Control.Monad.Exception: onException :: (Monad m) => EMT l m a -> EMT l m b -> EMT l m a

+ Control.Monad.Exception: onException :: Monad m => EMT l m a -> EMT l m b -> EMT l m a

- Control.Monad.Exception: runEMT :: (Monad m) => EMT NoExceptions m a -> m a

+ Control.Monad.Exception: runEMT :: Monad m => EMT NoExceptions m a -> m a

- Control.Monad.Exception: runEMTParanoid :: (Monad m) => EMT ParanoidMode m a -> m a

+ Control.Monad.Exception: runEMTParanoid :: Monad m => EMT ParanoidMode m a -> m a

- Control.Monad.Exception: showExceptionWithTrace :: (Exception e) => [String] -> e -> String

+ Control.Monad.Exception: showExceptionWithTrace :: Exception e => [String] -> e -> String

- Control.Monad.Exception: toException :: (Exception e) => e -> SomeException

+ Control.Monad.Exception: toException :: Exception e => e -> SomeException

- Control.Monad.Exception: try :: (Try f, ApplicativeFailure (Error f) f') => f a -> f' a

+ Control.Monad.Exception: try :: (Try f, Failure (Error f) f') => f a -> f' a

- Control.Monad.Exception: tryEMT :: (Monad m) => EMT AnyException m a -> m (Either SomeException a)

+ Control.Monad.Exception: tryEMT :: Monad m => EMT AnyException m a -> m (Either SomeException a)

- Control.Monad.Exception: typeOf :: (Typeable a) => a -> TypeRep

+ Control.Monad.Exception: typeOf :: Typeable a => a -> TypeRep

- Control.Monad.Exception: withLoc :: (MonadLoc m) => String -> m a -> m a

+ Control.Monad.Exception: withLoc :: MonadLoc m => String -> m a -> m a

- Control.Monad.Exception: wrapFailure :: (WrapFailure e f) => (forall eIn. (Exception eIn) => eIn -> e) -> f a -> f a

+ Control.Monad.Exception: wrapFailure :: WrapFailure e f => (forall eIn. Exception eIn => eIn -> e) -> f a -> f a

- Control.Monad.Exception.Base: bracket :: (Monad m) => EMT l m a -> (a -> EMT l m b) -> (a -> EMT l m c) -> EMT l m c

+ Control.Monad.Exception.Base: bracket :: Monad m => EMT l m a -> (a -> EMT l m b) -> (a -> EMT l m c) -> EMT l m c

- Control.Monad.Exception.Base: class (Exception e) => UncaughtException e

+ Control.Monad.Exception.Base: class Exception e => UncaughtException e

- Control.Monad.Exception.Base: finally :: (Monad m) => EMT l m a -> EMT l m b -> EMT l m a

+ Control.Monad.Exception.Base: finally :: Monad m => EMT l m a -> EMT l m b -> EMT l m a

- Control.Monad.Exception.Base: mplusDefault :: (Monad m) => EMT l m a -> EMT l m a -> EMT l m a

+ Control.Monad.Exception.Base: mplusDefault :: Monad m => EMT l m a -> EMT l m a -> EMT l m a

- Control.Monad.Exception.Base: onException :: (Monad m) => EMT l m a -> EMT l m b -> EMT l m a

+ Control.Monad.Exception.Base: onException :: Monad m => EMT l m a -> EMT l m b -> EMT l m a

- Control.Monad.Exception.Base: runEMT :: (Monad m) => EMT NoExceptions m a -> m a

+ Control.Monad.Exception.Base: runEMT :: Monad m => EMT NoExceptions m a -> m a

- Control.Monad.Exception.Base: runEMTParanoid :: (Monad m) => EMT ParanoidMode m a -> m a

+ Control.Monad.Exception.Base: runEMTParanoid :: Monad m => EMT ParanoidMode m a -> m a

- Control.Monad.Exception.Base: runEMT_gen :: (Monad m) => EMT l m a -> m a

+ Control.Monad.Exception.Base: runEMT_gen :: Monad m => EMT l m a -> m a

- Control.Monad.Exception.Base: showExceptionWithTrace :: (Exception e) => [String] -> e -> String

+ Control.Monad.Exception.Base: showExceptionWithTrace :: Exception e => [String] -> e -> String

- Control.Monad.Exception.Base: tryEMT :: (Monad m) => EMT AnyException m a -> m (Either SomeException a)

+ Control.Monad.Exception.Base: tryEMT :: Monad m => EMT AnyException m a -> m (Either SomeException a)

- Control.Monad.Exception.Base: tryEMTWithLoc :: (Monad m) => EMT AnyException m a -> m (Either (CallTrace, SomeException) a)

+ Control.Monad.Exception.Base: tryEMTWithLoc :: Monad m => EMT AnyException m a -> m (Either (CallTrace, SomeException) a)

- Control.Monad.Exception.Catch: catch :: (MonadCatch e m m') => m a -> (e -> m' a) -> m' a

+ Control.Monad.Exception.Catch: catch :: MonadCatch e m m' => m a -> (e -> m' a) -> m' a

- Control.Monad.Exception.Catch: catchWithSrcLoc :: (MonadCatch e m m') => m a -> ([String] -> e -> m' a) -> m' a

+ Control.Monad.Exception.Catch: catchWithSrcLoc :: MonadCatch e m m' => m a -> ([String] -> e -> m' a) -> m' a

- Control.Monad.Exception.Catch: fromException :: (Exception e) => SomeException -> Maybe e

+ Control.Monad.Exception.Catch: fromException :: Exception e => SomeException -> Maybe e

- Control.Monad.Exception.Catch: toException :: (Exception e) => e -> SomeException

+ Control.Monad.Exception.Catch: toException :: Exception e => e -> SomeException

- Control.Monad.Exception.Throws: class (Exception e) => Throws e l

+ Control.Monad.Exception.Throws: class Exception e => Throws e l

Files

Control/Monad/Exception.hs +2/−1
Control/Monad/Exception/Instances.hs +22/−0
control-monad-exception.cabal +4/−2

Control/Monad/Exception.hs view

@@ -75,12 +75,13 @@ -- * Reexports     Exception(..), SomeException(..), Typeable(..),     Try(..), NothingException(..),-    Failure(..), MonadFailure, WrapFailure(..),+    Failure(..), WrapFailure(..),     MonadLoc(..), withLocTH ) where  import Control.Monad.Exception.Base import Control.Monad.Exception.Catch+import Control.Monad.Exception.Instances() import Control.Failure import Control.Monad.Loc import Data.Typeable

+ Control/Monad/Exception/Instances.hs view

@@ -0,0 +1,22 @@+module Control.Monad.Exception.Instances where++import Control.Monad.Exception.Throws+import Data.Typeable+import Safe.Failure++-- Encoding the exception hierarchy of safe-failure++instance Throws TailFailure (Caught SafeException l)+instance Throws HeadFailure (Caught SafeException l)+instance Throws InitFailure (Caught SafeException l)+instance Throws LastFailure (Caught SafeException l)+instance Throws MinimumFailure (Caught SafeException l)+instance Throws MaximumFailure (Caught SafeException l)+instance Throws Foldr1Failure (Caught SafeException l)+instance Throws Foldl1Failure (Caught SafeException l)+instance Throws FromJustFailure (Caught SafeException l)+instance Throws IndexFailure (Caught SafeException l)+instance Throws ReadFailure (Caught SafeException l)+instance (Typeable a, Show a) => Throws (LookupFailure a) (Caught SafeException l)++

control-monad-exception.cabal view

@@ -1,5 +1,5 @@ name: control-monad-exception-version: 0.8.0.4+version: 0.9.0 Cabal-Version:  >= 1.6 build-type: Simple license: PublicDomain@@ -74,7 +74,8 @@  Library   buildable: True -  build-depends: failure+  build-depends: failure >= 0.1 && < 0.2+               , safe-failure >= 0.5                , monadloc    if flag(extensibleExceptions)@@ -99,6 +100,7 @@      Control.Monad.Exception.Base      Control.Monad.Exception.Catch      Control.Monad.Exception.Throws+     Control.Monad.Exception.Instances    ghc-options: -Wall -fno-warn-name-shadowing -fno-warn-orphans