{-# LANGUAGE CPP #-}
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE FunctionalDependencies #-}
{-# LANGUAGE MultiParamTypeClasses #-}
{-# LANGUAGE UndecidableInstances #-}
module Control.Monad.Error.Class (
    Error(..),
    MonadError(..),
    liftEither,
  ) where
import Control.Monad.Trans.Except (Except, ExceptT)
import Control.Monad.Trans.Error (Error(..), ErrorT)
import qualified Control.Monad.Trans.Except as ExceptT (throwE, catchE)
import qualified Control.Monad.Trans.Error as ErrorT (throwError, catchError)
import Control.Monad.Trans.Identity as Identity
import Control.Monad.Trans.List as List
import Control.Monad.Trans.Maybe as Maybe
import Control.Monad.Trans.Reader as Reader
import Control.Monad.Trans.RWS.Lazy as LazyRWS
import Control.Monad.Trans.RWS.Strict as StrictRWS
import Control.Monad.Trans.State.Lazy as LazyState
import Control.Monad.Trans.State.Strict as StrictState
import Control.Monad.Trans.Writer.Lazy as LazyWriter
import Control.Monad.Trans.Writer.Strict as StrictWriter
import Control.Monad.Trans.Class (lift)
import Control.Exception (IOException, catch, ioError)
import Control.Monad
#if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ < 707
import Control.Monad.Instances ()
#endif
import Data.Monoid
import Prelude (Either(..), Maybe(..), either, (.), IO)
class (Monad m) => MonadError e m | m -> e where
    
    throwError :: e -> m a
    
    catchError :: m a -> (e -> m a) -> m a
#if __GLASGOW_HASKELL__ >= 707
    {-# MINIMAL throwError, catchError #-}
#endif
liftEither :: MonadError e m => Either e a -> m a
liftEither :: forall e (m :: * -> *) a. MonadError e m => Either e a -> m a
liftEither = (e -> m a) -> (a -> m a) -> Either e a -> m a
forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either e -> m a
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError a -> m a
forall a. a -> m a
forall (m :: * -> *) a. Monad m => a -> m a
return
instance MonadError IOException IO where
    throwError :: forall a. IOException -> IO a
throwError = IOException -> IO a
forall a. IOException -> IO a
ioError
    catchError :: forall a. IO a -> (IOException -> IO a) -> IO a
catchError = IO a -> (IOException -> IO a) -> IO a
forall e a. Exception e => IO a -> (e -> IO a) -> IO a
catch
instance MonadError () Maybe where
    throwError :: forall a. () -> Maybe a
throwError ()        = Maybe a
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             = e -> Either e a
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
_ = a -> Either e a
forall a b. b -> Either a b
Right a
r
instance (Monad m, Error e) => MonadError e (ErrorT e m) where
    throwError :: forall a. e -> ErrorT e m a
throwError = e -> ErrorT e m a
forall (m :: * -> *) e a. Monad m => e -> ErrorT e m a
ErrorT.throwError
    catchError :: forall a. ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a
catchError = ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a
forall (m :: * -> *) e a.
Monad m =>
ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a
ErrorT.catchError
instance Monad m => MonadError e (ExceptT e m) where
    throwError :: forall a. e -> ExceptT e m a
throwError = e -> ExceptT e m a
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 = ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a
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 = m a -> IdentityT m a
forall (m :: * -> *) a. Monad m => m a -> IdentityT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> IdentityT m a) -> (e -> m a) -> e -> IdentityT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m a -> Catch e (IdentityT m) a
forall {k} e (m :: k -> *) (a :: k).
Catch e m a -> Catch e (IdentityT m) a
Identity.liftCatch Catch e m a
forall a. m a -> (e -> m a) -> m a
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
catchError
instance MonadError e m => MonadError e (ListT m) where
    throwError :: forall a. e -> ListT m a
throwError = m a -> ListT m a
forall (m :: * -> *) a. Monad m => m a -> ListT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ListT m a) -> (e -> m a) -> e -> ListT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
forall e (m :: * -> *) a. MonadError e m => e -> m a
throwError
    catchError :: forall a. ListT m a -> (e -> ListT m a) -> ListT m a
catchError = Catch e m [a] -> Catch e (ListT m) a
forall e (m :: * -> *) a. Catch e m [a] -> Catch e (ListT m) a
List.liftCatch Catch e m [a]
forall a. m a -> (e -> m a) -> m a
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 = m a -> MaybeT m a
forall (m :: * -> *) a. Monad m => m a -> MaybeT m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> MaybeT m a) -> (e -> m a) -> e -> MaybeT m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m (Maybe a) -> Catch e (MaybeT m) a
forall e (m :: * -> *) a.
Catch e m (Maybe a) -> Catch e (MaybeT m) a
Maybe.liftCatch Catch e m (Maybe a)
forall a. m a -> (e -> m a) -> m a
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 = m a -> ReaderT r m a
forall (m :: * -> *) a. Monad m => m a -> ReaderT r m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> ReaderT r m a) -> (e -> m a) -> e -> ReaderT r m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m a -> Catch e (ReaderT r m) a
forall e (m :: * -> *) a r. Catch e m a -> Catch e (ReaderT r m) a
Reader.liftCatch Catch e m a
forall a. m a -> (e -> m a) -> m a
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 = m a -> RWST r w s m a
forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> RWST r w s m a) -> (e -> m a) -> e -> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m (a, s, w) -> Catch e (RWST r w s m) a
forall e (m :: * -> *) a s w r.
Catch e m (a, s, w) -> Catch e (RWST r w s m) a
LazyRWS.liftCatch Catch e m (a, s, w)
forall a. m a -> (e -> m a) -> m a
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 = m a -> RWST r w s m a
forall (m :: * -> *) a. Monad m => m a -> RWST r w s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> RWST r w s m a) -> (e -> m a) -> e -> RWST r w s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m (a, s, w) -> Catch e (RWST r w s m) a
forall e (m :: * -> *) a s w r.
Catch e m (a, s, w) -> Catch e (RWST r w s m) a
StrictRWS.liftCatch Catch e m (a, s, w)
forall a. m a -> (e -> m a) -> m a
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 = m a -> StateT s m a
forall (m :: * -> *) a. Monad m => m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT s m a) -> (e -> m a) -> e -> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m (a, s) -> Catch e (StateT s m) a
forall e (m :: * -> *) a s.
Catch e m (a, s) -> Catch e (StateT s m) a
LazyState.liftCatch Catch e m (a, s)
forall a. m a -> (e -> m a) -> m a
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 = m a -> StateT s m a
forall (m :: * -> *) a. Monad m => m a -> StateT s m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> StateT s m a) -> (e -> m a) -> e -> StateT s m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m (a, s) -> Catch e (StateT s m) a
forall e (m :: * -> *) a s.
Catch e m (a, s) -> Catch e (StateT s m) a
StrictState.liftCatch Catch e m (a, s)
forall a. m a -> (e -> m a) -> m a
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 = m a -> WriterT w m a
forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> WriterT w m a) -> (e -> m a) -> e -> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m (a, w) -> Catch e (WriterT w m) a
forall e (m :: * -> *) a w.
Catch e m (a, w) -> Catch e (WriterT w m) a
LazyWriter.liftCatch Catch e m (a, w)
forall a. m a -> (e -> m a) -> m a
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 = m a -> WriterT w m a
forall (m :: * -> *) a. Monad m => m a -> WriterT w m a
forall (t :: (* -> *) -> * -> *) (m :: * -> *) a.
(MonadTrans t, Monad m) =>
m a -> t m a
lift (m a -> WriterT w m a) -> (e -> m a) -> e -> WriterT w m a
forall b c a. (b -> c) -> (a -> b) -> a -> c
. e -> m a
forall a. e -> m a
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 = Catch e m (a, w) -> Catch e (WriterT w m) a
forall e (m :: * -> *) a w.
Catch e m (a, w) -> Catch e (WriterT w m) a
StrictWriter.liftCatch Catch e m (a, w)
forall a. m a -> (e -> m a) -> m a
forall e (m :: * -> *) a.
MonadError e m =>
m a -> (e -> m a) -> m a
catchError