packages feed

monad-finally 0.1.2 → 0.1.2.1

raw patch · 4 files changed

+20/−7 lines, 4 filesdep ~monad-abort-fdPVP: minor bump suggested

API additions: PVP suggests at least a minor version bump

Dependency ranges changed: monad-abort-fd

API changes (from Hackage documentation)

+ Control.Monad.Exception: AllocationLimitExceeded :: AllocationLimitExceeded
+ Control.Monad.Exception: AssertionFailed :: String -> AssertionFailed
+ Control.Monad.Exception: BlockedIndefinitelyOnMVar :: BlockedIndefinitelyOnMVar
+ Control.Monad.Exception: BlockedIndefinitelyOnSTM :: BlockedIndefinitelyOnSTM
+ Control.Monad.Exception: CompactionFailed :: String -> CompactionFailed
+ Control.Monad.Exception: Deadlock :: Deadlock
+ Control.Monad.Exception: Denormal :: ArithException
+ Control.Monad.Exception: DivideByZero :: ArithException
+ Control.Monad.Exception: ErrorCallWithLocation :: String -> String -> ErrorCall
+ Control.Monad.Exception: HeapOverflow :: AsyncException
+ Control.Monad.Exception: IndexOutOfBounds :: String -> ArrayException
+ Control.Monad.Exception: LossOfPrecision :: ArithException
+ Control.Monad.Exception: MaskedInterruptible :: MaskingState
+ Control.Monad.Exception: MaskedUninterruptible :: MaskingState
+ Control.Monad.Exception: NestedAtomically :: NestedAtomically
+ Control.Monad.Exception: NoMethodError :: String -> NoMethodError
+ Control.Monad.Exception: NonTermination :: NonTermination
+ Control.Monad.Exception: Overflow :: ArithException
+ Control.Monad.Exception: PatternMatchFail :: String -> PatternMatchFail
+ Control.Monad.Exception: RatioZeroDenominator :: ArithException
+ Control.Monad.Exception: RecConError :: String -> RecConError
+ Control.Monad.Exception: RecSelError :: String -> RecSelError
+ Control.Monad.Exception: RecUpdError :: String -> RecUpdError
+ Control.Monad.Exception: SomeAsyncException :: e -> SomeAsyncException
+ Control.Monad.Exception: SomeException :: e -> SomeException
+ Control.Monad.Exception: StackOverflow :: AsyncException
+ Control.Monad.Exception: ThreadKilled :: AsyncException
+ Control.Monad.Exception: TypeError :: String -> TypeError
+ Control.Monad.Exception: UndefinedElement :: String -> ArrayException
+ Control.Monad.Exception: Underflow :: ArithException
+ Control.Monad.Exception: Unmasked :: MaskingState
+ Control.Monad.Exception: UserInterrupt :: AsyncException
+ Control.Monad.Exception: assert :: Bool -> a -> a
+ Control.Monad.Exception: asyncExceptionFromException :: Exception e => SomeException -> Maybe e
+ Control.Monad.Exception: asyncExceptionToException :: Exception e => e -> SomeException
+ Control.Monad.Exception: class (Typeable e, Show e) => Exception e
+ Control.Monad.Exception: data AllocationLimitExceeded
+ Control.Monad.Exception: data ArithException
+ Control.Monad.Exception: data ArrayException
+ Control.Monad.Exception: data AsyncException
+ Control.Monad.Exception: data BlockedIndefinitelyOnMVar
+ Control.Monad.Exception: data BlockedIndefinitelyOnSTM
+ Control.Monad.Exception: data Deadlock
+ Control.Monad.Exception: data ErrorCall
+ Control.Monad.Exception: data IOException
+ Control.Monad.Exception: data MaskingState
+ Control.Monad.Exception: data NestedAtomically
+ Control.Monad.Exception: data NonTermination
+ Control.Monad.Exception: data SomeAsyncException
+ Control.Monad.Exception: data SomeException
+ Control.Monad.Exception: displayException :: Exception e => e -> String
+ Control.Monad.Exception: fromException :: Exception e => SomeException -> Maybe e
+ Control.Monad.Exception: mapException :: (Exception e1, Exception e2) => (e1 -> e2) -> a -> a
+ Control.Monad.Exception: newtype AssertionFailed
+ Control.Monad.Exception: newtype CompactionFailed
+ Control.Monad.Exception: newtype NoMethodError
+ Control.Monad.Exception: newtype PatternMatchFail
+ Control.Monad.Exception: newtype RecConError
+ Control.Monad.Exception: newtype RecSelError
+ Control.Monad.Exception: newtype RecUpdError
+ Control.Monad.Exception: newtype TypeError
+ Control.Monad.Exception: pattern ErrorCall :: String -> ErrorCall
+ Control.Monad.Exception: toException :: Exception e => e -> SomeException

Files

README.md view
@@ -1,7 +1,7 @@ Monad-Finally ============= -[![Travis](https://img.shields.io/travis/mvv/monad-finally/master.svg)](https://travis-ci.org/mvv/monad-finally) [![Hackage](https://img.shields.io/hackage/v/monad-finally.svg)](http://hackage.haskell.org/package/monad-finally)+[![Build](https://github.com/mvv/monad-finally/actions/workflows/ci.yml/badge.svg)](https://github.com/mvv/monad-finally/actions/workflows/ci.yml) [![Hackage](https://img.shields.io/hackage/v/monad-finally.svg)](http://hackage.haskell.org/package/monad-finally)  This package provides a generalized version of `Control.Exception.finally`. The cleanup action is run not only on successful termination of the main
monad-finally.cabal view
@@ -1,5 +1,5 @@ Name: monad-finally-Version: 0.1.2+Version: 0.1.2.1 Category: Control Stability: experimental Synopsis: Guard monadic computations with cleanup actions@@ -23,9 +23,10 @@   README.md  Tested-With: GHC==7.6.3, GHC==7.8.4, GHC==7.10.3, GHC==8.0.2, GHC==8.2.2,-             GHC==8.4.1+             GHC==8.4.4, GHC==8.6.5, GHC==8.8.4, GHC==8.10.7, GHC==9.0.2,+             GHC==9.2.7, GHC==9.4.5, GHC==9.6.1 -Cabal-Version: >= 1.6.0+Cabal-Version: >= 1.10.0 Build-Type: Simple  Source-Repository head@@ -33,12 +34,13 @@   Location: https://github.com/mvv/monad-finally.git  Library-  Build-Depends: base >= 4.4 && < 5-  Build-Depends: transformers        >= 0.2+  Default-Language: Haskell2010+  Build-Depends: base                >= 4.4 && < 5+               , transformers        >= 0.2                , transformers-compat >= 0.6.1                , transformers-base   >= 0.4                , transformers-abort  >= 0.6-               , monad-abort-fd      >= 0.6.2+               , monad-abort-fd      >= 0.7.0.1                , monad-control       >= 1.0   Hs-Source-Dirs: src   GHC-Options: -Wall
src/Control/Monad/Exception.hs view
@@ -3,6 +3,7 @@ {-# LANGUAGE MagicHash #-} {-# LANGUAGE LambdaCase #-} {-# LANGUAGE DefaultSignatures #-}+{-# LANGUAGE TypeOperators #-} {-# LANGUAGE ExistentialQuantification #-} {-# LANGUAGE ScopedTypeVariables #-} {-# LANGUAGE ConstraintKinds #-}@@ -68,8 +69,10 @@ import Control.Monad.Trans.Abort hiding (abort, recover) import Control.Monad.Trans.Finish import Control.Monad.Trans.Maybe+#if !MIN_VERSION_transformers(0,6,0) import Control.Monad.Trans.List import Control.Monad.Trans.Error+#endif import Control.Monad.Trans.Except import Control.Monad.Trans.Reader import qualified Control.Monad.Trans.State.Lazy as L@@ -229,10 +232,14 @@   withMaskingState MaskedUninterruptible (IO io) = IO $ maskUninterruptible# io  instance MonadMask μ ⇒ MonadMask (MaybeT μ)+#if !MIN_VERSION_transformers(0,6,0) instance MonadMask μ ⇒ MonadMask (ListT μ)+#endif instance MonadMask μ ⇒ MonadMask (AbortT e μ) instance MonadMask μ ⇒ MonadMask (FinishT β μ)+#if !MIN_VERSION_transformers(0,6,0) instance (MonadMask μ, Error e) ⇒ MonadMask (ErrorT e μ)+#endif instance MonadMask μ ⇒ MonadMask (ExceptT e μ) instance MonadMask μ ⇒ MonadMask (ReaderT r μ) instance MonadMask μ ⇒ MonadMask (L.StateT s μ)
src/Control/Monad/Finally.hs view
@@ -25,7 +25,9 @@ import Control.Applicative (Applicative(..), (<$>), (<$)) import Control.Monad (join) import Control.Monad.Trans.Maybe+#if !MIN_VERSION_transformers(0,6,0) import Control.Monad.Trans.Error+#endif import Control.Monad.Trans.Except import Control.Monad.Trans.Reader import qualified Control.Monad.Trans.State.Lazy as L@@ -136,6 +138,7 @@                         (fmap join . mapM (runFinishT . m))     return $ (,) <$> mr <*> rr +#if !MIN_VERSION_transformers(0,6,0) instance (MonadFinally μ, Error e) ⇒ MonadFinally (ErrorT e μ) where   finally' m f = ErrorT $ do     (mr, fr) ← finally' (runErrorT m) (runErrorT . f . justRight)@@ -147,6 +150,7 @@                           Left e → const (return (Left e)))                         (fmap join . mapM (runErrorT . m))     return $ (,) <$> mr <*> rr+#endif  instance MonadFinally μ ⇒ MonadFinally (ExceptT e μ) where   finally' m f = ExceptT $ do