(original) (raw)

{-# LANGUAGE FlexibleInstances #-} {-# LANGUAGE FunctionalDependencies #-} {-# LANGUAGE MultiParamTypeClasses #-} {-# LANGUAGE UndecidableInstances #-} {-# LANGUAGE Safe #-}

{-# OPTIONS_GHC -Wno-redundant-constraints #-}

module Control.Monad.Error.Class ( MonadError(..), liftEither, tryError, withError, handleError, mapError, modifyError, ) where

import Control.Monad.Trans.Except (ExceptT) import qualified Control.Monad.Trans.Except as ExceptT (catchE, runExceptT, throwE) import Control.Monad.Trans.Identity (IdentityT) import qualified Control.Monad.Trans.Identity as Identity import Control.Monad.Trans.Maybe (MaybeT) import qualified Control.Monad.Trans.Maybe as Maybe import Control.Monad.Trans.Reader (ReaderT) import qualified Control.Monad.Trans.Reader as Reader import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS import qualified Control.Monad.Trans.RWS.Strict as StrictRWS import qualified Control.Monad.Trans.State.Lazy as LazyState import qualified Control.Monad.Trans.State.Strict as StrictState import qualified Control.Monad.Trans.Writer.Lazy as LazyWriter import qualified Control.Monad.Trans.Writer.Strict as StrictWriter import Control.Monad.Trans.Accum (AccumT) import qualified Control.Monad.Trans.Accum as Accum import qualified Control.Monad.Trans.RWS.CPS as CPSRWS import qualified Control.Monad.Trans.Writer.CPS as CPSWriter import Control.Monad.Trans.Class (lift) import Control.Exception (IOException, catch, ioError) import Control.Monad (Monad) import Data.Monoid (Monoid) import Prelude (Either (Left, Right), Maybe (Nothing), either, flip, (.), IO, pure, (<$>), (>>=))

class (Monad m) => MonadError e m | m -> e where

[throwError](Control.Monad.Error.Class.html#throwError) :: [e](#local-6989586621679045106) -> [m](#local-6989586621679045105) [a](#local-6989586621679045094)


[catchError](Control.Monad.Error.Class.html#catchError) :: [m](#local-6989586621679045105) [a](#local-6989586621679045091) -> ([e](#local-6989586621679045106) -> [m](#local-6989586621679045105) [a](#local-6989586621679045091)) -> [m](#local-6989586621679045105) [a](#local-6989586621679045091)
{-# MINIMAL [throwError](Control.Monad.Error.Class.html#throwError), [catchError](Control.Monad.Error.Class.html#catchError) #-}

liftEither :: MonadError e m => Either e a -> m a liftEither :: forall e (m :: * -> *) a. MonadError e m => Either e a -> m a liftEither = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c either forall e (m :: * -> *) a. MonadError e m => e -> m a throwError forall (f :: * -> *) a. Applicative f => a -> f a pure

instance MonadError IOException IO where throwError :: forall a. IOException -> IO a throwError = forall a. IOException -> IO a ioError catchError :: forall a. IO a -> (IOException -> IO a) -> IO a catchError = forall e a. Exception e => IO a -> (e -> IO a) -> IO a catch

instance MonadError () Maybe where throwError :: forall a. () -> Maybe a throwError () = forall a. Maybe a Nothing catchError :: forall a. Maybe a -> (() -> Maybe a) -> Maybe a catchError Maybe a Nothing () -> Maybe a f = () -> Maybe a f () catchError Maybe a x () -> Maybe a _ = Maybe a x

instance MonadError e (Either e) where throwError :: forall a. e -> Either e a throwError = forall e a. e -> Either e a Left Left e l catchError :: forall a. Either e a -> (e -> Either e a) -> Either e a catchError e -> Either e a h = e -> Either e a h e l Right a r catchError e -> Either e a _ = forall a b. b -> Either a b Right a r

instance Monad m => MonadError e (ExceptT e m) where throwError :: forall a. e -> ExceptT e m a throwError = forall (m :: * -> *) e a. Monad m => e -> ExceptT e m a ExceptT.throwE catchError :: forall a. ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a catchError = forall (m :: * -> *) e a e'. Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a ExceptT.catchE

instance MonadError e m => MonadError e (IdentityT m) where throwError :: forall a. e -> IdentityT m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. IdentityT m a -> (e -> IdentityT m a) -> IdentityT m a catchError = forall {k} e (m :: k -> *) (a :: k). Catch e m a -> Catch e (IdentityT m) a Identity.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance MonadError e m => MonadError e (MaybeT m) where throwError :: forall a. e -> MaybeT m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a catchError = forall e (m :: * -> *) a. Catch e m (Maybe a) -> Catch e (MaybeT m) a Maybe.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance MonadError e m => MonadError e (ReaderT r m) where throwError :: forall a. e -> ReaderT r m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. ReaderT r m a -> (e -> ReaderT r m a) -> ReaderT r m a catchError = forall e (m :: * -> *) a r. Catch e m a -> Catch e (ReaderT r m) a Reader.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance (Monoid w, MonadError e m) => MonadError e (LazyRWS.RWST r w s m) where throwError :: forall a. e -> RWST r w s m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a catchError = forall e (m :: * -> *) a s w r. Catch e m (a, s, w) -> Catch e (RWST r w s m) a LazyRWS.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance (Monoid w, MonadError e m) => MonadError e (StrictRWS.RWST r w s m) where throwError :: forall a. e -> RWST r w s m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a catchError = forall e (m :: * -> *) a s w r. Catch e m (a, s, w) -> Catch e (RWST r w s m) a StrictRWS.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance MonadError e m => MonadError e (LazyState.StateT s m) where throwError :: forall a. e -> StateT s m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. StateT s m a -> (e -> StateT s m a) -> StateT s m a catchError = forall e (m :: * -> *) a s. Catch e m (a, s) -> Catch e (StateT s m) a LazyState.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance MonadError e m => MonadError e (StrictState.StateT s m) where throwError :: forall a. e -> StateT s m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. StateT s m a -> (e -> StateT s m a) -> StateT s m a catchError = forall e (m :: * -> *) a s. Catch e m (a, s) -> Catch e (StateT s m) a StrictState.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance (Monoid w, MonadError e m) => MonadError e (LazyWriter.WriterT w m) where throwError :: forall a. e -> WriterT w m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a catchError = forall e (m :: * -> *) a w. Catch e m (a, w) -> Catch e (WriterT w m) a LazyWriter.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance (Monoid w, MonadError e m) => MonadError e (StrictWriter.WriterT w m) where throwError :: forall a. e -> WriterT w m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a catchError = forall e (m :: * -> *) a w. Catch e m (a, w) -> Catch e (WriterT w m) a StrictWriter.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance (Monoid w, MonadError e m) => MonadError e (CPSRWS.RWST r w s m) where throwError :: forall a. e -> RWST r w s m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a catchError = forall e (m :: * -> *) a s w r. Catch e m (a, s, w) -> Catch e (RWST r w s m) a CPSRWS.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance (Monoid w, MonadError e m) => MonadError e (CPSWriter.WriterT w m) where throwError :: forall a. e -> WriterT w m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a catchError = forall e (m :: * -> *) a w. Catch e m (a, w) -> Catch e (WriterT w m) a CPSWriter.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

instance ( Monoid w , MonadError e m ) => MonadError e (AccumT w m) where throwError :: forall a. e -> AccumT w m a throwError = forall (t :: (* -> *) -> * -> *) (m :: * -> *) a. (MonadTrans t, Monad m) => m a -> t m a lift forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e (m :: * -> *) a. MonadError e m => e -> m a throwError catchError :: forall a. AccumT w m a -> (e -> AccumT w m a) -> AccumT w m a catchError = forall e (m :: * -> *) a w. Catch e m (a, w) -> Catch e (AccumT w m) a Accum.liftCatch forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

tryError :: MonadError e m => m a -> m (Either e a) tryError :: forall e (m :: * -> *) a. MonadError e m => m a -> m (Either e a) tryError m a action = (forall a b. b -> Either a b Right forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b <$> m a action) forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError (forall (f :: * -> *) a. Applicative f => a -> f a pure forall b c a. (b -> c) -> (a -> b) -> a -> c . forall e a. e -> Either e a Left)

withError :: MonadError e m => (e -> e) -> m a -> m a withError :: forall e (m :: * -> *) a. MonadError e m => (e -> e) -> m a -> m a withError e -> e f m a action = forall e (m :: * -> *) a. MonadError e m => m a -> m (Either e a) tryError m a action forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c either (forall e (m :: * -> *) a. MonadError e m => e -> m a throwError forall b c a. (b -> c) -> (a -> b) -> a -> c . e -> e f) forall (f :: * -> *) a. Applicative f => a -> f a pure

handleError :: MonadError e m => (e -> m a) -> m a -> m a handleError :: forall e (m :: * -> *) a. MonadError e m => (e -> m a) -> m a -> m a handleError = forall a b c. (a -> b -> c) -> b -> a -> c flip forall e (m :: * -> *) a. MonadError e m => m a -> (e -> m a) -> m a catchError

mapError :: (MonadError e m, MonadError e' n) => (m (Either e a) -> n (Either e' b)) -> m a -> n b mapError :: forall e (m :: * -> *) e' (n :: * -> *) a b. (MonadError e m, MonadError e' n) => (m (Either e a) -> n (Either e' b)) -> m a -> n b mapError m (Either e a) -> n (Either e' b) f m a action = m (Either e a) -> n (Either e' b) f (forall e (m :: * -> *) a. MonadError e m => m a -> m (Either e a) tryError m a action) forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

= forall e (m :: * -> *) a. MonadError e m => Either e a -> m a liftEither

modifyError :: MonadError e' m => (e -> e') -> ExceptT e m a -> m a modifyError :: forall e' (m :: * -> *) e a. MonadError e' m => (e -> e') -> ExceptT e m a -> m a modifyError e -> e' f ExceptT e m a m = forall e (m :: * -> *) a. ExceptT e m a -> m (Either e a) ExceptT.runExceptT ExceptT e m a m forall (m :: * -> *) a b. Monad m => m a -> (a -> m b) -> m b

= forall a c b. (a -> c) -> (b -> c) -> Either a b -> c either (forall e (m :: * -> *) a. MonadError e m => e -> m a throwError forall b c a. (b -> c) -> (a -> b) -> a -> c . e -> e' f) forall (f :: * -> *) a. Applicative f => a -> f a pure