explicit-exception 0.1.7.3 → 0.1.8

raw patch · 4 files changed

+18/−3 lines, 4 filesdep +deepseqdep ~transformersPVP: major bump suggested

API removals or changes: PVP suggests a major version bump

Dependencies added: deepseq

Dependency ranges changed: transformers

API changes (from Hackage documentation)

- Control.Monad.Exception.Asynchronous.Lazy: exception :: Exceptional e a -> Maybe e

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

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

- Control.Monad.Exception.Asynchronous.Lazy: instance Functor (Exceptional e)

- Control.Monad.Exception.Asynchronous.Lazy: instance Functor m => Functor (ExceptionalT e m)

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

- Control.Monad.Exception.Asynchronous.Lazy: result :: Exceptional e a -> a

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

- Control.Monad.Exception.Asynchronous.Strict: exception :: Exceptional e a -> Maybe e

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

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

- Control.Monad.Exception.Asynchronous.Strict: instance Functor (Exceptional e)

- Control.Monad.Exception.Asynchronous.Strict: instance Functor m => Functor (ExceptionalT e m)

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

- Control.Monad.Exception.Asynchronous.Strict: result :: Exceptional e a -> a

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

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

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

- Control.Monad.Exception.Synchronous: instance Applicative (Exceptional e)

- Control.Monad.Exception.Synchronous: instance Applicative m => Applicative (ExceptionalT e m)

- Control.Monad.Exception.Synchronous: instance Functor (Exceptional e)

- Control.Monad.Exception.Synchronous: instance Functor m => Functor (ExceptionalT e m)

- Control.Monad.Exception.Synchronous: instance Monad (Exceptional e)

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

- Control.Monad.Exception.Synchronous: instance MonadFix (Exceptional e)

- Control.Monad.Exception.Synchronous: instance MonadFix m => MonadFix (ExceptionalT e m)

- Control.Monad.Exception.Synchronous: instance MonadTrans (ExceptionalT e)

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

+ Control.Monad.Exception.Asynchronous.Lazy: [exception] :: Exceptional e a -> Maybe e

+ Control.Monad.Exception.Asynchronous.Lazy: [result] :: Exceptional e a -> a

+ Control.Monad.Exception.Asynchronous.Lazy: [runExceptionalT] :: ExceptionalT e m a -> m (Exceptional e a)

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

+ Control.Monad.Exception.Asynchronous.Lazy: instance (GHC.Base.Monad m, GHC.Base.Monoid a) => GHC.Base.Monoid (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.Functor (Control.Monad.Exception.Asynchronous.Lazy.Exceptional e)

+ Control.Monad.Exception.Asynchronous.Lazy: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Exception.Asynchronous.Lazy.ExceptionalT e m)

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

+ Control.Monad.Exception.Asynchronous.Strict: [exception] :: Exceptional e a -> Maybe e

+ Control.Monad.Exception.Asynchronous.Strict: [result] :: Exceptional e a -> a

+ Control.Monad.Exception.Asynchronous.Strict: [runExceptionalT] :: ExceptionalT e m a -> m (Exceptional e a)

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

+ Control.Monad.Exception.Asynchronous.Strict: instance (GHC.Base.Monad m, GHC.Base.Monoid a) => GHC.Base.Monoid (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.Functor (Control.Monad.Exception.Asynchronous.Strict.Exceptional e)

+ Control.Monad.Exception.Asynchronous.Strict: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Exception.Asynchronous.Strict.ExceptionalT e m)

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

+ Control.Monad.Exception.Synchronous: [runExceptionalT] :: ExceptionalT e m a -> m (Exceptional e a)

+ Control.Monad.Exception.Synchronous: instance (Control.DeepSeq.NFData e, Control.DeepSeq.NFData a) => Control.DeepSeq.NFData (Control.Monad.Exception.Synchronous.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.Synchronous: instance Control.Monad.Fix.MonadFix (Control.Monad.Exception.Synchronous.Exceptional e)

+ Control.Monad.Exception.Synchronous: instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Exception.Synchronous.ExceptionalT e m)

+ Control.Monad.Exception.Synchronous: instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Exception.Synchronous.ExceptionalT e)

+ Control.Monad.Exception.Synchronous: instance GHC.Base.Applicative (Control.Monad.Exception.Synchronous.Exceptional e)

+ Control.Monad.Exception.Synchronous: instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Monad.Exception.Synchronous.ExceptionalT e m)

+ Control.Monad.Exception.Synchronous: instance GHC.Base.Functor (Control.Monad.Exception.Synchronous.Exceptional e)

+ Control.Monad.Exception.Synchronous: instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Exception.Synchronous.ExceptionalT e m)

+ Control.Monad.Exception.Synchronous: instance GHC.Base.Monad (Control.Monad.Exception.Synchronous.Exceptional e)

+ Control.Monad.Exception.Synchronous: instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Exception.Synchronous.ExceptionalT e m)

- 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: 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: 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 +6/−3
src/Control/Monad/Exception/Asynchronous/Lazy.hs +4/−0
src/Control/Monad/Exception/Asynchronous/Strict.hs +4/−0
src/Control/Monad/Exception/Synchronous.hs +4/−0

explicit-exception.cabal view

@@ -1,5 +1,5 @@ Name:             explicit-exception-Version:          0.1.7.3+Version:          0.1.8 License:          BSD3 License-File:     LICENSE Author:           Henning Thielemann <haskell@henning-thielemann.de>@@ -37,6 +37,7 @@    and may cause further damage. Tested-With:       GHC==6.8.2 Tested-With:       GHC==7.4.2, GHC==7.6.1, GHC==7.8.2+Tested-With:       GHC==8.0.1 Cabal-Version:     >=1.6 Build-Type:        Simple @@ -47,7 +48,7 @@ Source-Repository this   type:     darcs   location: http://code.haskell.org/explicit-exception/-  tag:      0.1.7.3+  tag:      0.1.8  Flag buildTests   description: Build executables that demonstrate some space leaks@@ -58,7 +59,9 @@   Library-  Build-Depends: transformers >=0.2 && <0.5+  Build-Depends:+    transformers >=0.2 && <0.6,+    deepseq >=1.1 && <1.5   If impl(jhc)     Build-Depends:       applicative >=1.0 && <1.1,

src/Control/Monad/Exception/Asynchronous/Lazy.hs view

@@ -47,6 +47,7 @@  import Control.Monad (Monad, return, liftM, mplus, join, (>>=), (>>), ) import Control.Applicative (Applicative, liftA, )+import Control.DeepSeq (NFData, rnf, ) import Data.Functor (Functor, fmap, ) {- import Data.Traversable (Traversable, )@@ -202,6 +203,9 @@ maybeAbort ~(Exceptional ea a) eb =    Exceptional (mplus ea eb) a ++instance (NFData e, NFData a) => NFData (Exceptional e a) where+   rnf (Exceptional e a) = rnf (e, a)  {- | 'mappend' must be strict in order to fulfill the Monoid laws

src/Control/Monad/Exception/Asynchronous/Strict.hs view

@@ -47,6 +47,7 @@  import Control.Monad (Monad, return, liftM, mplus, join, (>>=), (>>), ) import Control.Applicative (Applicative, liftA, )+import Control.DeepSeq (NFData, rnf, ) import Data.Functor (Functor, fmap, ) {- import Data.Traversable (Traversable, )@@ -196,6 +197,9 @@ maybeAbort (Exceptional ea a) eb =    Exceptional (mplus ea eb) a ++instance (NFData e, NFData a) => NFData (Exceptional e a) where+   rnf (Exceptional e a) = rnf (e, a)  {- | 'mappend' must be strict in order to fulfill the Monoid laws

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

@@ -70,6 +70,7 @@ import Control.Monad.Trans.Class (MonadTrans, lift, ) import Control.Monad.Trans.Error (ErrorT(ErrorT, runErrorT)) import Control.Monad.Trans.Maybe (MaybeT(MaybeT, runMaybeT))+import Control.DeepSeq (NFData, rnf, ) import Data.Functor (Functor, fmap, ) import Data.Monoid(Monoid, mappend, mempty, Endo(Endo, appEndo), ) import Data.Function (flip, const, (.), ($), )@@ -223,6 +224,9 @@       (Success _, Exception e) -> Exception e       (Exception e0, Exception e1) -> Exception $ mappend e0 e1 ++instance (NFData e, NFData a) => NFData (Exceptional e a) where+   rnf = switch rnf rnf  instance Functor (Exceptional e) where    fmap f x =