packages feed

errors 2.0.1 → 2.1.0

raw patch · 2 files changed

+13/−27 lines, 2 filesdep +unexceptionalioPVP ok

version bump matches the API change (PVP)

Dependencies added: unexceptionalio

API changes (from Hackage documentation)

- Control.Error.Util: instance (Monoid e, Monoid r) => Monoid (AllE e r)
- Control.Error.Util: instance (Monoid e, Monoid r) => Monoid (AnyE e r)
- Control.Error.Util: runAllE :: AllE e r -> Either e r
- Control.Error.Util: runAnyE :: AnyE e r -> Either e r
- Data.EitherR: instance (Monad m, Monoid r) => Alternative (ExceptRT r m)
- Data.EitherR: instance (Monad m, Monoid r) => MonadPlus (ExceptRT r m)
- Data.EitherR: instance Applicative (EitherR r)
- Data.EitherR: instance Functor (EitherR r)
- Data.EitherR: instance Monad (EitherR r)
- Data.EitherR: instance Monad m => Applicative (ExceptRT r m)
- Data.EitherR: instance Monad m => Functor (ExceptRT r m)
- Data.EitherR: instance Monad m => Monad (ExceptRT r m)
- Data.EitherR: instance MonadIO m => MonadIO (ExceptRT r m)
- Data.EitherR: instance MonadTrans (ExceptRT r)
- Data.EitherR: instance Monoid r => Alternative (EitherR r)
- Data.EitherR: instance Monoid r => MonadPlus (EitherR r)
- Data.EitherR: runEitherR :: EitherR r e -> Either e r
- Data.EitherR: runExceptRT :: ExceptRT r m e -> ExceptT e m r
+ Control.Error.Util: [runAllE] :: AllE e r -> Either e r
+ Control.Error.Util: [runAnyE] :: AnyE e r -> Either e r
+ Control.Error.Util: instance (GHC.Base.Monoid e, GHC.Base.Monoid r) => GHC.Base.Monoid (Control.Error.Util.AllE e r)
+ Control.Error.Util: instance (GHC.Base.Monoid e, GHC.Base.Monoid r) => GHC.Base.Monoid (Control.Error.Util.AnyE e r)
+ Data.EitherR: [runEitherR] :: EitherR r e -> Either e r
+ Data.EitherR: [runExceptRT] :: ExceptRT r m e -> ExceptT e m r
+ Data.EitherR: instance (GHC.Base.Monad m, GHC.Base.Monoid r) => GHC.Base.Alternative (Data.EitherR.ExceptRT r m)
+ Data.EitherR: instance (GHC.Base.Monad m, GHC.Base.Monoid r) => GHC.Base.MonadPlus (Data.EitherR.ExceptRT r m)
+ Data.EitherR: instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Data.EitherR.ExceptRT r m)
+ Data.EitherR: instance Control.Monad.Trans.Class.MonadTrans (Data.EitherR.ExceptRT r)
+ Data.EitherR: instance GHC.Base.Applicative (Data.EitherR.EitherR r)
+ Data.EitherR: instance GHC.Base.Functor (Data.EitherR.EitherR r)
+ Data.EitherR: instance GHC.Base.Monad (Data.EitherR.EitherR r)
+ Data.EitherR: instance GHC.Base.Monad m => GHC.Base.Applicative (Data.EitherR.ExceptRT r m)
+ Data.EitherR: instance GHC.Base.Monad m => GHC.Base.Functor (Data.EitherR.ExceptRT r m)
+ Data.EitherR: instance GHC.Base.Monad m => GHC.Base.Monad (Data.EitherR.ExceptRT r m)
+ Data.EitherR: instance GHC.Base.Monoid r => GHC.Base.Alternative (Data.EitherR.EitherR r)
+ Data.EitherR: instance GHC.Base.Monoid r => GHC.Base.MonadPlus (Data.EitherR.EitherR r)
- Control.Error.Safe: assertZ :: MonadPlus m => Bool -> m ()
+ Control.Error.Safe: assertZ :: (MonadPlus m) => Bool -> m ()
- Control.Error.Safe: atZ :: MonadPlus m => [a] -> Int -> m a
+ Control.Error.Safe: atZ :: (MonadPlus m) => [a] -> Int -> m a
- Control.Error.Safe: foldl1Z :: MonadPlus m => (a -> a -> a) -> [a] -> m a
+ Control.Error.Safe: foldl1Z :: (MonadPlus m) => (a -> a -> a) -> [a] -> m a
- Control.Error.Safe: foldl1Z' :: MonadPlus m => (a -> a -> a) -> [a] -> m a
+ Control.Error.Safe: foldl1Z' :: (MonadPlus m) => (a -> a -> a) -> [a] -> m a
- Control.Error.Safe: foldr1Z :: MonadPlus m => (a -> a -> a) -> [a] -> m a
+ Control.Error.Safe: foldr1Z :: (MonadPlus m) => (a -> a -> a) -> [a] -> m a
- Control.Error.Safe: headZ :: MonadPlus m => [a] -> m a
+ Control.Error.Safe: headZ :: (MonadPlus m) => [a] -> m a
- Control.Error.Safe: initZ :: MonadPlus m => [a] -> m [a]
+ Control.Error.Safe: initZ :: (MonadPlus m) => [a] -> m [a]
- Control.Error.Safe: justZ :: MonadPlus m => Maybe a -> m a
+ Control.Error.Safe: justZ :: (MonadPlus m) => Maybe a -> m a
- Control.Error.Safe: lastZ :: MonadPlus m => [a] -> m a
+ Control.Error.Safe: lastZ :: (MonadPlus m) => [a] -> m a
- Control.Error.Safe: maximumErr :: Ord a => e -> [a] -> Either e a
+ Control.Error.Safe: maximumErr :: (Ord a) => e -> [a] -> Either e a
- Control.Error.Safe: maximumZ :: MonadPlus m => Ord a => [a] -> m a
+ Control.Error.Safe: maximumZ :: (MonadPlus m) => (Ord a) => [a] -> m a
- Control.Error.Safe: minimumErr :: Ord a => e -> [a] -> Either e a
+ Control.Error.Safe: minimumErr :: (Ord a) => e -> [a] -> Either e a
- Control.Error.Safe: minimumZ :: MonadPlus m => Ord a => [a] -> m a
+ Control.Error.Safe: minimumZ :: (MonadPlus m) => (Ord a) => [a] -> m a
- Control.Error.Safe: readErr :: Read a => e -> String -> Either e a
+ Control.Error.Safe: readErr :: (Read a) => e -> String -> Either e a
- Control.Error.Safe: readZ :: MonadPlus m => Read a => String -> m a
+ Control.Error.Safe: readZ :: (MonadPlus m) => (Read a) => String -> m a
- Control.Error.Safe: rightZ :: MonadPlus m => Either e a -> m a
+ Control.Error.Safe: rightZ :: (MonadPlus m) => Either e a -> m a
- Control.Error.Safe: tailZ :: MonadPlus m => [a] -> m [a]
+ Control.Error.Safe: tailZ :: (MonadPlus m) => [a] -> m [a]
- Control.Error.Safe: tryAssert :: Monad m => e -> Bool -> ExceptT e m ()
+ Control.Error.Safe: tryAssert :: (Monad m) => e -> Bool -> ExceptT e m ()
- Control.Error.Safe: tryAt :: Monad m => e -> [a] -> Int -> ExceptT e m a
+ Control.Error.Safe: tryAt :: (Monad m) => e -> [a] -> Int -> ExceptT e m a
- Control.Error.Safe: tryFoldl1 :: Monad m => e -> (a -> a -> a) -> [a] -> ExceptT e m a
+ Control.Error.Safe: tryFoldl1 :: (Monad m) => e -> (a -> a -> a) -> [a] -> ExceptT e m a
- Control.Error.Safe: tryFoldl1' :: Monad m => e -> (a -> a -> a) -> [a] -> ExceptT e m a
+ Control.Error.Safe: tryFoldl1' :: (Monad m) => e -> (a -> a -> a) -> [a] -> ExceptT e m a
- Control.Error.Safe: tryFoldr1 :: Monad m => e -> (a -> a -> a) -> [a] -> ExceptT e m a
+ Control.Error.Safe: tryFoldr1 :: (Monad m) => e -> (a -> a -> a) -> [a] -> ExceptT e m a
- Control.Error.Safe: tryHead :: Monad m => e -> [a] -> ExceptT e m a
+ Control.Error.Safe: tryHead :: (Monad m) => e -> [a] -> ExceptT e m a
- Control.Error.Safe: tryInit :: Monad m => e -> [a] -> ExceptT e m [a]
+ Control.Error.Safe: tryInit :: (Monad m) => e -> [a] -> ExceptT e m [a]
- Control.Error.Safe: tryJust :: Monad m => e -> Maybe a -> ExceptT e m a
+ Control.Error.Safe: tryJust :: (Monad m) => e -> Maybe a -> ExceptT e m a
- Control.Error.Safe: tryLast :: Monad m => e -> [a] -> ExceptT e m a
+ Control.Error.Safe: tryLast :: (Monad m) => e -> [a] -> ExceptT e m a
- Control.Error.Safe: tryRight :: Monad m => Either e a -> ExceptT e m a
+ Control.Error.Safe: tryRight :: (Monad m) => Either e a -> ExceptT e m a
- Control.Error.Safe: tryTail :: Monad m => e -> [a] -> ExceptT e m [a]
+ Control.Error.Safe: tryTail :: (Monad m) => e -> [a] -> ExceptT e m [a]
- Control.Error.Script: scriptIO :: MonadIO m => IO a -> ExceptT String m a
+ Control.Error.Script: scriptIO :: (MonadIO m) => IO a -> ExceptT String m a
- Control.Error.Util: fmapRT :: Monad m => (a -> b) -> ExceptT l m a -> ExceptT l m b
+ Control.Error.Util: fmapRT :: (Monad m) => (a -> b) -> ExceptT l m a -> ExceptT l m b
- Control.Error.Util: hoistMaybe :: Monad m => Maybe b -> MaybeT m b
+ Control.Error.Util: hoistMaybe :: (Monad m) => Maybe b -> MaybeT m b
- Control.Error.Util: hushT :: Monad m => ExceptT a m b -> MaybeT m b
+ Control.Error.Util: hushT :: (Monad m) => ExceptT a m b -> MaybeT m b
- Control.Error.Util: isJustT :: Monad m => MaybeT m a -> m Bool
+ Control.Error.Util: isJustT :: (Monad m) => MaybeT m a -> m Bool
- Control.Error.Util: isLeftT :: Monad m => ExceptT a m b -> m Bool
+ Control.Error.Util: isLeftT :: (Monad m) => ExceptT a m b -> m Bool
- Control.Error.Util: isNothingT :: Monad m => MaybeT m a -> m Bool
+ Control.Error.Util: isNothingT :: (Monad m) => MaybeT m a -> m Bool
- Control.Error.Util: isRightT :: Monad m => ExceptT a m b -> m Bool
+ Control.Error.Util: isRightT :: (Monad m) => ExceptT a m b -> m Bool
- Control.Error.Util: just :: Monad m => a -> MaybeT m a
+ Control.Error.Util: just :: (Monad m) => a -> MaybeT m a
- Control.Error.Util: noteT :: Monad m => a -> MaybeT m b -> ExceptT a m b
+ Control.Error.Util: noteT :: (Monad m) => a -> MaybeT m b -> ExceptT a m b
- Control.Error.Util: nothing :: Monad m => MaybeT m a
+ Control.Error.Util: nothing :: (Monad m) => MaybeT m a
- Control.Error.Util: syncIO :: MonadIO m => IO a -> ExceptT SomeException m a
+ Control.Error.Util: syncIO :: Unexceptional m => IO a -> ExceptT SomeException m a
- Data.EitherR: flipET :: Monad m => ExceptT a m b -> ExceptT b m a
+ Data.EitherR: flipET :: (Monad m) => ExceptT a m b -> ExceptT b m a
- Data.EitherR: fmapLT :: Monad m => (a -> b) -> ExceptT a m r -> ExceptT b m r
+ Data.EitherR: fmapLT :: (Monad m) => (a -> b) -> ExceptT a m r -> ExceptT b m r
- Data.EitherR: handleE :: Monad m => (a -> ExceptT b m r) -> ExceptT a m r -> ExceptT b m r
+ Data.EitherR: handleE :: (Monad m) => (a -> ExceptT b m r) -> ExceptT a m r -> ExceptT b m r
- Data.EitherR: succeedT :: Monad m => r -> ExceptRT r m e
+ Data.EitherR: succeedT :: (Monad m) => r -> ExceptRT r m e

Files

Control/Error/Util.hs view
@@ -51,7 +51,7 @@     ) where  import Control.Applicative (Applicative, pure, (<$>))-import qualified Control.Exception as Ex+import Control.Exception (Handler(..), IOException, SomeException) import Control.Monad (liftM) import Control.Monad.IO.Class (MonadIO(liftIO)) import Control.Monad.Trans.Except (ExceptT(ExceptT), runExceptT)@@ -61,7 +61,11 @@ import Data.Maybe (fromMaybe) import System.Exit (ExitCode) import System.IO (hPutStr, hPutStrLn, stderr)+import UnexceptionalIO (UIO, Unexceptional) +import qualified Control.Exception as Exception+import qualified UnexceptionalIO   as UIO+ -- | Fold an 'ExceptT' by providing one continuation for each constructor exceptT :: Monad m => (a -> m c) -> (b -> m c) -> ExceptT a m b -> m c exceptT f g (ExceptT m) = m >>= \z -> case z of@@ -231,31 +235,12 @@ errLn :: String -> IO () errLn = hPutStrLn stderr --- | Catch 'Ex.IOException's and convert them to the 'ExceptT' monad-tryIO :: (MonadIO m) => IO a -> ExceptT Ex.IOException m a-tryIO = ExceptT . liftIO . Ex.try+-- | Catch 'IOException's and convert them to the 'ExceptT' monad+tryIO :: MonadIO m => IO a -> ExceptT IOException m a+tryIO = ExceptT . liftIO . Exception.try  {-| Catch all exceptions, except for asynchronous exceptions found in @base@     and convert them to the 'ExceptT' monad -}-syncIO :: MonadIO m => IO a -> ExceptT Ex.SomeException m a-syncIO a = ExceptT . liftIO $ Ex.catches (Right <$> a)-    [ Ex.Handler $ \e -> Ex.throw (e :: Ex.ArithException)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.ArrayException)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.AssertionFailed)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.AsyncException)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.BlockedIndefinitelyOnMVar)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.BlockedIndefinitelyOnSTM)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.Deadlock)-    , Ex.Handler $ \e -> Ex.throw (e ::    Dynamic)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.ErrorCall)-    , Ex.Handler $ \e -> Ex.throw (e ::    ExitCode)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.NestedAtomically)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.NoMethodError)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.NonTermination)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.PatternMatchFail)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.RecConError)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.RecSelError)-    , Ex.Handler $ \e -> Ex.throw (e :: Ex.RecUpdError)-    , Ex.Handler $ return . Left-    ]+syncIO :: Unexceptional m => IO a -> ExceptT SomeException m a+syncIO = ExceptT . UIO.liftUIO . UIO.fromIO
errors.cabal view
@@ -1,5 +1,5 @@ Name: errors-Version: 2.0.1+Version: 2.1.0 Cabal-Version: >=1.8.0.2 Build-Type: Simple License: BSD3@@ -25,7 +25,8 @@         base                >= 4     && < 5  ,         safe                >= 0.3.3 && < 0.4,         transformers        >= 0.2   && < 0.5,-        transformers-compat >= 0.4   && < 0.5+        transformers-compat >= 0.4   && < 0.5,+        unexceptionalio     >= 0.3   && < 0.4     Exposed-Modules:         Control.Error,         Control.Error.Safe,