explicit-exception 0.1.9.2 → 0.1.10

raw patch · 3 files changed

+7/−8 lines, 3 filesPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

API changes (from Hackage documentation)

- Control.Monad.Exception.Asynchronous.Lazy: instance (GHC.Base.Monad m, GHC.Base.Monoid a) => Data.Semigroup.Semigroup (Control.Monad.Exception.Asynchronous.Lazy.ExceptionalT e m a)

- Control.Monad.Exception.Asynchronous.Lazy: instance (GHC.Show.Show a, GHC.Show.Show e) => GHC.Show.Show (Control.Monad.Exception.Asynchronous.Lazy.Exceptional e a)

- Control.Monad.Exception.Asynchronous.Lazy: instance GHC.Base.Monoid a => Data.Semigroup.Semigroup (Control.Monad.Exception.Asynchronous.Lazy.Exceptional e a)

- Control.Monad.Exception.Asynchronous.Strict: instance (GHC.Base.Monad m, GHC.Base.Monoid a) => Data.Semigroup.Semigroup (Control.Monad.Exception.Asynchronous.Strict.ExceptionalT e m a)

- Control.Monad.Exception.Asynchronous.Strict: instance (GHC.Show.Show a, GHC.Show.Show e) => GHC.Show.Show (Control.Monad.Exception.Asynchronous.Strict.Exceptional e a)

- Control.Monad.Exception.Asynchronous.Strict: instance GHC.Base.Monoid a => Data.Semigroup.Semigroup (Control.Monad.Exception.Asynchronous.Strict.Exceptional e a)

- Control.Monad.Exception.Synchronous: instance (GHC.Classes.Eq e, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Monad.Exception.Synchronous.Exceptional e a)

- Control.Monad.Exception.Synchronous: instance (GHC.Show.Show e, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Exception.Synchronous.Exceptional e a)

+ Control.Monad.Exception.Asynchronous.Lazy: instance (GHC.Base.Monad m, GHC.Base.Monoid a) => GHC.Base.Semigroup (Control.Monad.Exception.Asynchronous.Lazy.ExceptionalT e m a)

+ Control.Monad.Exception.Asynchronous.Lazy: instance (GHC.Show.Show e, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Exception.Asynchronous.Lazy.Exceptional e a)

+ Control.Monad.Exception.Asynchronous.Lazy: instance GHC.Base.Monoid a => GHC.Base.Semigroup (Control.Monad.Exception.Asynchronous.Lazy.Exceptional e a)

+ Control.Monad.Exception.Asynchronous.Strict: instance (GHC.Base.Monad m, GHC.Base.Monoid a) => GHC.Base.Semigroup (Control.Monad.Exception.Asynchronous.Strict.ExceptionalT e m a)

+ Control.Monad.Exception.Asynchronous.Strict: instance (GHC.Show.Show e, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Exception.Asynchronous.Strict.Exceptional e a)

+ Control.Monad.Exception.Asynchronous.Strict: instance GHC.Base.Monoid a => GHC.Base.Semigroup (Control.Monad.Exception.Asynchronous.Strict.Exceptional e a)

+ Control.Monad.Exception.Synchronous: instance (GHC.Classes.Eq a, GHC.Classes.Eq e) => GHC.Classes.Eq (Control.Monad.Exception.Synchronous.Exceptional e a)

+ Control.Monad.Exception.Synchronous: instance (GHC.Show.Show a, GHC.Show.Show e) => GHC.Show.Show (Control.Monad.Exception.Synchronous.Exceptional e a)

- Control.Monad.Exception.Asynchronous.Lazy: manySynchronousT :: (Monad m) => (m (Exceptional e b) -> m (Exceptional e b)) -> (a -> b -> b) -> b -> ExceptionalT e m a -> m (Exceptional e b)

+ Control.Monad.Exception.Asynchronous.Lazy: manySynchronousT :: Monad m => (m (Exceptional e b) -> m (Exceptional e b)) -> (a -> b -> b) -> b -> ExceptionalT e m a -> m (Exceptional e b)

- Control.Monad.Exception.Asynchronous.Lazy: mapExceptionT :: (Monad m) => (e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a

+ Control.Monad.Exception.Asynchronous.Lazy: mapExceptionT :: Monad m => (e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a

- Control.Monad.Exception.Asynchronous.Lazy: processToSynchronousT_ :: (Monad m) => (b -> Maybe (a, b)) -> (a -> ExceptionalT e m ()) -> Exceptional e b -> ExceptionalT e m ()

+ Control.Monad.Exception.Asynchronous.Lazy: processToSynchronousT_ :: Monad m => (b -> Maybe (a, b)) -> (a -> ExceptionalT e m ()) -> Exceptional e b -> ExceptionalT e m ()

- Control.Monad.Exception.Asynchronous.Lazy: simultaneousBindM :: (Monad m) => m (Exceptional e a) -> (a -> m (Exceptional e b)) -> m (Exceptional e b)

+ Control.Monad.Exception.Asynchronous.Lazy: simultaneousBindM :: Monad m => m (Exceptional e a) -> (a -> m (Exceptional e b)) -> m (Exceptional e b)

- Control.Monad.Exception.Asynchronous.Strict: manySynchronousT :: (Monad m) => (m (Exceptional e b) -> m (Exceptional e b)) -> (a -> b -> b) -> b -> ExceptionalT e m a -> m (Exceptional e b)

+ Control.Monad.Exception.Asynchronous.Strict: manySynchronousT :: Monad m => (m (Exceptional e b) -> m (Exceptional e b)) -> (a -> b -> b) -> b -> ExceptionalT e m a -> m (Exceptional e b)

- Control.Monad.Exception.Asynchronous.Strict: mapExceptionT :: (Monad m) => (e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a

+ Control.Monad.Exception.Asynchronous.Strict: mapExceptionT :: Monad m => (e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a

- Control.Monad.Exception.Asynchronous.Strict: processToSynchronousT_ :: (Monad m) => (b -> Maybe (a, b)) -> (a -> ExceptionalT e m ()) -> Exceptional e b -> ExceptionalT e m ()

+ Control.Monad.Exception.Asynchronous.Strict: processToSynchronousT_ :: Monad m => (b -> Maybe (a, b)) -> (a -> ExceptionalT e m ()) -> Exceptional e b -> ExceptionalT e m ()

- Control.Monad.Exception.Asynchronous.Strict: simultaneousBindM :: (Monad m) => m (Exceptional e a) -> (a -> m (Exceptional e b)) -> m (Exceptional e b)

+ Control.Monad.Exception.Asynchronous.Strict: simultaneousBindM :: Monad m => m (Exceptional e a) -> (a -> m (Exceptional e b)) -> m (Exceptional e b)

- Control.Monad.Exception.Synchronous: alternativeT :: (Monad m) => ExceptionalT e m a -> ExceptionalT e m a -> ExceptionalT e m a

+ Control.Monad.Exception.Synchronous: alternativeT :: Monad m => ExceptionalT e m a -> ExceptionalT e m a -> ExceptionalT e m a

- Control.Monad.Exception.Synchronous: assertT :: (Monad m) => e -> Bool -> ExceptionalT e m ()

+ Control.Monad.Exception.Synchronous: assertT :: Monad m => e -> Bool -> ExceptionalT e m ()

- Control.Monad.Exception.Synchronous: bracketT :: (Monad m) => ExceptionalT e m h -> (h -> ExceptionalT e m ()) -> (h -> ExceptionalT e m a) -> ExceptionalT e m a

+ Control.Monad.Exception.Synchronous: bracketT :: Monad m => ExceptionalT e m h -> (h -> ExceptionalT e m ()) -> (h -> ExceptionalT e m a) -> ExceptionalT e m a

- Control.Monad.Exception.Synchronous: catchT :: (Monad m) => ExceptionalT e0 m a -> (e0 -> ExceptionalT e1 m a) -> ExceptionalT e1 m a

+ Control.Monad.Exception.Synchronous: catchT :: Monad m => ExceptionalT e0 m a -> (e0 -> ExceptionalT e1 m a) -> ExceptionalT e1 m a

- Control.Monad.Exception.Synchronous: fromExitCodeT :: (Functor m) => m ExitCode -> ExceptionalT Int m ()

+ Control.Monad.Exception.Synchronous: fromExitCodeT :: Functor m => m ExitCode -> ExceptionalT Int m ()

- Control.Monad.Exception.Synchronous: liftT :: (Monad m) => Exceptional e a -> ExceptionalT e m a

+ Control.Monad.Exception.Synchronous: liftT :: Monad m => Exceptional e a -> ExceptionalT e m a

- Control.Monad.Exception.Synchronous: manyT :: (Monad m) => (e0 -> Maybe e1) -> (a -> b -> b) -> b -> ExceptionalT e0 m a -> ExceptionalT e1 m b

+ Control.Monad.Exception.Synchronous: manyT :: Monad m => (e0 -> Maybe e1) -> (a -> b -> b) -> b -> ExceptionalT e0 m a -> ExceptionalT e1 m b

- Control.Monad.Exception.Synchronous: mapExceptionT :: (Monad m) => (e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a

+ Control.Monad.Exception.Synchronous: mapExceptionT :: Monad m => (e0 -> e1) -> ExceptionalT e0 m a -> ExceptionalT e1 m a

- Control.Monad.Exception.Synchronous: merge :: (Monoid e) => Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b

+ Control.Monad.Exception.Synchronous: merge :: Monoid e => Exceptional e (a -> b) -> Exceptional e a -> Exceptional e b

- Control.Monad.Exception.Synchronous: resolveT :: (Monad m) => (e -> m a) -> ExceptionalT e m a -> m a

+ Control.Monad.Exception.Synchronous: resolveT :: Monad m => (e -> m a) -> ExceptionalT e m a -> m a

- Control.Monad.Exception.Synchronous: switchT :: (Monad m) => (e -> m b) -> (a -> m b) -> ExceptionalT e m a -> m b

+ Control.Monad.Exception.Synchronous: switchT :: Monad m => (e -> m b) -> (a -> m b) -> ExceptionalT e m a -> m b

- Control.Monad.Exception.Synchronous: throwT :: (Monad m) => e -> ExceptionalT e m a

+ Control.Monad.Exception.Synchronous: throwT :: Monad m => e -> ExceptionalT e m a

- Control.Monad.Exception.Synchronous: toExitCodeT :: (Functor m) => ExceptionalT Int m () -> m ExitCode

+ Control.Monad.Exception.Synchronous: toExitCodeT :: Functor m => ExceptionalT Int m () -> m ExitCode

- Control.Monad.Exception.Synchronous: tryT :: (Monad m) => ExceptionalT e m a -> m (Exceptional e a)

+ Control.Monad.Exception.Synchronous: tryT :: Monad m => ExceptionalT e m a -> m (Exceptional e a)

Files

explicit-exception.cabal +2/−2
src/Control/Monad/Exception/Synchronous.hs +5/−2
src/Control/Monad/Exception/Warning.hs +0/−4

explicit-exception.cabal view

@@ -1,5 +1,5 @@ Name:             explicit-exception-Version:          0.1.9.2+Version:          0.1.10 License:          BSD3 License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de>@@ -41,7 +41,7 @@ Source-Repository this   type:     darcs   location: http://hub.darcs.net/thielema/explicit-exception/-  tag:      0.1.9.2+  tag:      0.1.10  Flag buildTests   description: Build executables that demonstrate some space leaks

src/Control/Monad/Exception/Synchronous.hs view

@@ -67,7 +67,7 @@    ) where  import Control.Applicative (Applicative(pure, (<*>)))-import Control.Monad (Monad, return, fail, liftM, liftM2, (>>=), (>>), (=<<),+import Control.Monad (Monad, return, liftM, liftM2, (>>=), (>>), (=<<),           {- MonadPlus(mzero, mplus), -}) import Control.Monad.Fix (MonadFix, mfix, ) import Control.Monad.Trans.Class (MonadTrans, lift, )@@ -200,6 +200,10 @@       Success a   -> a       Exception e -> handler e +{-+Semigroup instance could replace (Math.Checksum.IBAN.+++).+-}+ -- like Applicative.<|> infixl 3 `alternative`, `alternativeT` @@ -257,7 +261,6 @@  instance Monad (Exceptional e) where    return = Success-   fail _msg = Exception (error "Exception.Synchronous: Monad.fail method is not supported")    x >>= f =       case x of          Exception e -> Exception e

src/Control/Monad/Exception/Warning.hs view

@@ -75,10 +75,6 @@  instance Monad (Warnable e) where    return = Warnable [] -- [Nothing]?-   fail _msg =-      Warnable-         [Just (error "Warning.fail exception")]-         (error "Warning.fail result")    x >>= f =       case x of          Warnable e0 y ->