Safe Haskell	Safe
Language	Haskell98

Network.Gitit.Compat.Except

Synopsis

Documentation

data ExceptT e m a :: * -> (* -> *) -> * -> * #

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

e - The exception type.
m - The inner monad.

The return function yields a computation that produces the given value, while >>= sequences two subcomputations, exiting on the first exception.

Instances

WebMonad a m => WebMonad a (ExceptT e m)
Methods finishWith :: a -> ExceptT e m b
FilterMonad a m => FilterMonad a (ExceptT e m)
Methods setFilter :: (a -> a) -> ExceptT e m () composeFilter :: (a -> a) -> ExceptT e m () getFilter :: ExceptT e m b -> ExceptT e m (b, a -> a)
MonadReader r m => MonadReader r (ExceptT e m)
Methods ask :: ExceptT e m r local :: (r -> r) -> ExceptT e m a -> ExceptT e m a reader :: (r -> a) -> ExceptT e m a
MonadState s m => MonadState s (ExceptT e m)
Methods get :: ExceptT e m s put :: s -> ExceptT e m () state :: (s -> (a, s)) -> ExceptT e m a
Monad m => MonadError e (ExceptT e m)
Methods throwError :: e -> ExceptT e m a # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a #
MonadBaseControl b m => MonadBaseControl b (ExceptT e m)
Associated Types type StM (ExceptT e m :: * -> ) a :: Methods liftBaseWith :: (RunInBase (ExceptT e m) b -> b a) -> ExceptT e m a restoreM :: StM (ExceptT e m) a -> ExceptT e m a
MonadTrans (ExceptT e)
Methods lift :: Monad m => m a -> ExceptT e m a #
MonadTransControl (ExceptT e)
Associated Types type StT (ExceptT e :: (* -> ) -> -> ) a :: Methods liftWith :: Monad m => (Run (ExceptT e) -> m a) -> ExceptT e m a restoreT :: Monad m => m (StT (ExceptT e) a) -> ExceptT e m a
Monad m => Monad (ExceptT e m)
Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a # fail :: String -> ExceptT e m a #
Functor m => Functor (ExceptT e m)
Methods fmap :: (a -> b) -> ExceptT e m a -> ExceptT e m b # (<$) :: a -> ExceptT e m b -> ExceptT e m a #
MonadFix m => MonadFix (ExceptT e m)
Methods mfix :: (a -> ExceptT e m a) -> ExceptT e m a #
MonadFail m => MonadFail (ExceptT e m)
Methods fail :: String -> ExceptT e m a #
(Functor m, Monad m) => Applicative (ExceptT e m)
Methods pure :: a -> ExceptT e m a # (<>) :: ExceptT e m (a -> b) -> ExceptT e m a -> ExceptT e m b # (>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # (<*) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m a #
Foldable f => Foldable (ExceptT e f)
Methods fold :: Monoid m => ExceptT e f m -> m # foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m # foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b # foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b # foldr1 :: (a -> a -> a) -> ExceptT e f a -> a # foldl1 :: (a -> a -> a) -> ExceptT e f a -> a # toList :: ExceptT e f a -> [a] # null :: ExceptT e f a -> Bool # length :: ExceptT e f a -> Int # elem :: Eq a => a -> ExceptT e f a -> Bool # maximum :: Ord a => ExceptT e f a -> a # minimum :: Ord a => ExceptT e f a -> a # sum :: Num a => ExceptT e f a -> a # product :: Num a => ExceptT e f a -> a #
Traversable f => Traversable (ExceptT e f)
Methods traverse :: Applicative f => (a -> f b) -> ExceptT e f a -> f (ExceptT e f b) # sequenceA :: Applicative f => ExceptT e f (f a) -> f (ExceptT e f a) # mapM :: Monad m => (a -> m b) -> ExceptT e f a -> m (ExceptT e f b) # sequence :: Monad m => ExceptT e f (m a) -> m (ExceptT e f a) #
(Eq e, Eq1 m) => Eq1 (ExceptT e m)
Methods liftEq :: (a -> b -> Bool) -> ExceptT e m a -> ExceptT e m b -> Bool #
(Ord e, Ord1 m) => Ord1 (ExceptT e m)
Methods liftCompare :: (a -> b -> Ordering) -> ExceptT e m a -> ExceptT e m b -> Ordering #
(Read e, Read1 m) => Read1 (ExceptT e m)
Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ExceptT e m a) # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ExceptT e m a] #
(Show e, Show1 m) => Show1 (ExceptT e m)
Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ExceptT e m a -> ShowS # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ExceptT e m a] -> ShowS #
MonadZip m => MonadZip (ExceptT e m)
Methods mzip :: ExceptT e m a -> ExceptT e m b -> ExceptT e m (a, b) # mzipWith :: (a -> b -> c) -> ExceptT e m a -> ExceptT e m b -> ExceptT e m c # munzip :: ExceptT e m (a, b) -> (ExceptT e m a, ExceptT e m b) #
MonadIO m => MonadIO (ExceptT e m)
Methods liftIO :: IO a -> ExceptT e m a #
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m)
Methods empty :: ExceptT e m a # (<\|>) :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # some :: ExceptT e m a -> ExceptT e m [a] # many :: ExceptT e m a -> ExceptT e m [a] #
(Monad m, Monoid e) => MonadPlus (ExceptT e m)
Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
(Monad m, HasDynFlags m) => HasDynFlags (ExceptT e m)
Methods getDynFlags :: ExceptT e m DynFlags #
MonadResource m => MonadResource (ExceptT e m)
Methods liftResourceT :: ResourceT IO a -> ExceptT e m a
(Monad m, HasRqData m) => HasRqData (ExceptT e m)
Methods askRqEnv :: ExceptT e m RqEnv localRqEnv :: (RqEnv -> RqEnv) -> ExceptT e m a -> ExceptT e m a rqDataError :: Errors String -> ExceptT e m a
(Happstack m, Monoid e) => Happstack (ExceptT e m)

ServerMonad m => ServerMonad (ExceptT e m)
Methods askRq :: ExceptT e m Request localRq :: (Request -> Request) -> ExceptT e m a -> ExceptT e m a
PrimMonad m => PrimMonad (ExceptT e m)
Associated Types type PrimState (ExceptT e m :: * -> ) :: Methods primitive :: (State# (PrimState (ExceptT e m)) -> (#VoidRep, PtrRepLifted, State# (PrimState (ExceptT e m)), a#)) -> ExceptT e m a
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a)
Methods (==) :: ExceptT e m a -> ExceptT e m a -> Bool # (/=) :: ExceptT e m a -> ExceptT e m a -> Bool #
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a)
Methods compare :: ExceptT e m a -> ExceptT e m a -> Ordering # (<) :: ExceptT e m a -> ExceptT e m a -> Bool # (<=) :: ExceptT e m a -> ExceptT e m a -> Bool # (>) :: ExceptT e m a -> ExceptT e m a -> Bool # (>=) :: ExceptT e m a -> ExceptT e m a -> Bool # max :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a # min :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
(Read e, Read1 m, Read a) => Read (ExceptT e m a)
Methods readsPrec :: Int -> ReadS (ExceptT e m a) # readList :: ReadS [ExceptT e m a] # readPrec :: ReadPrec (ExceptT e m a) # readListPrec :: ReadPrec [ExceptT e m a] #
(Show e, Show1 m, Show a) => Show (ExceptT e m a)
Methods showsPrec :: Int -> ExceptT e m a -> ShowS # show :: ExceptT e m a -> String # showList :: [ExceptT e m a] -> ShowS #
type StT (ExceptT e) a
type StT (ExceptT e) a = Either e a
type PrimState (ExceptT e m)
type PrimState (ExceptT e m) = PrimState m
type StM (ExceptT e m) a
type StM (ExceptT e m) a = ComposeSt (ExceptT e) m a

type Except e = ExceptT e Identity #

The parameterizable exception monad.

Computations are either exceptions or normal values.

The return function returns a normal value, while >>= exits on the first exception. For a variant that continues after an error and collects all the errors, see Errors.

class Error a where Source #

Methods

noMsg :: a Source #

strMsg :: String -> a Source #

runExceptT :: ExceptT e m a -> m (Either e a) #

The inverse of ExceptT.

runExcept :: Except e a -> Either e a #

Extractor for computations in the exception monad. (The inverse of except).

class Monad m => MonadError e m | m -> e where #

Minimal complete definition

throwError, catchError

Methods

throwError :: e -> m a #

catchError :: m a -> (e -> m a) -> m a #

Instances

MonadError IOException IO
Methods throwError :: IOException -> IO a # catchError :: IO a -> (IOException -> IO a) -> IO a #
MonadError e m => MonadError e (MaybeT m)
Methods throwError :: e -> MaybeT m a # catchError :: MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a #
MonadError e m => MonadError e (ListT m)
Methods throwError :: e -> ListT m a # catchError :: ListT m a -> (e -> ListT m a) -> ListT m a #
MonadError e (Either e)
Methods throwError :: e -> Either e a # catchError :: Either e a -> (e -> Either e a) -> Either e a #
MonadError e m => MonadError e (ResourceT m)
Methods throwError :: e -> ResourceT m a # catchError :: ResourceT m a -> (e -> ResourceT m a) -> ResourceT m a #
MonadError e m => MonadError e (WebT m)
Methods throwError :: e -> WebT m a # catchError :: WebT m a -> (e -> WebT m a) -> WebT m a #
(Monad m, MonadError e m) => MonadError e (ServerPartT m)
Methods throwError :: e -> ServerPartT m a # catchError :: ServerPartT m a -> (e -> ServerPartT m a) -> ServerPartT m a #
(Monoid w, MonadError e m) => MonadError e (WriterT w m)
Methods throwError :: e -> WriterT w m a # catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
(Monoid w, MonadError e m) => MonadError e (WriterT w m)
Methods throwError :: e -> WriterT w m a # catchError :: WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a #
MonadError e m => MonadError e (StateT s m)
Methods throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadError e m => MonadError e (StateT s m)
Methods throwError :: e -> StateT s m a # catchError :: StateT s m a -> (e -> StateT s m a) -> StateT s m a #
MonadError e m => MonadError e (IdentityT * m)
Methods throwError :: e -> IdentityT * m a # catchError :: IdentityT * m a -> (e -> IdentityT * m a) -> IdentityT * m a #
Monad m => MonadError e (ExceptT e m)
Methods throwError :: e -> ExceptT e m a # catchError :: ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a #
(Monad m, Error e) => MonadError e (ErrorT e m)
Methods throwError :: e -> ErrorT e m a # catchError :: ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a #
MonadError e m => MonadError e (ReaderT * r m)
Methods throwError :: e -> ReaderT * r m a # catchError :: ReaderT * r m a -> (e -> ReaderT * r m a) -> ReaderT * r m a #
MonadError e m => MonadError e (ParsecT s u m)
Methods throwError :: e -> ParsecT s u m a # catchError :: ParsecT s u m a -> (e -> ParsecT s u m a) -> ParsecT s u m a #
MonadError e m => MonadError e (ConduitM i o m)
Methods throwError :: e -> ConduitM i o m a # catchError :: ConduitM i o m a -> (e -> ConduitM i o m a) -> ConduitM i o m a #
(Monoid w, MonadError e m) => MonadError e (RWST r w s m)
Methods throwError :: e -> RWST r w s m a # catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
(Monoid w, MonadError e m) => MonadError e (RWST r w s m)
Methods throwError :: e -> RWST r w s m a # catchError :: RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a #
MonadError e m => MonadError e (Pipe l i o u m)
Methods throwError :: e -> Pipe l i o u m a # catchError :: Pipe l i o u m a -> (e -> Pipe l i o u m a) -> Pipe l i o u m a #

throwError :: MonadError e m => forall a. e -> m a #

catchError :: MonadError e m => forall a. m a -> (e -> m a) -> m a #