gitit-0.12.1: Wiki using happstack, git or darcs, and pandoc.

Safe Haskell | Safe
Language | Haskell98

Network.Gitit.Compat.Except

Synopsis

- data ExceptT e m a :: * -> (* -> *) -> * -> *
- type Except e = ExceptT e Identity
- class Error a where
  - noMsg :: a
  - strMsg :: String -> a
- runExceptT :: ExceptT e m a -> m (Either e a)
- runExcept :: Except e a -> Either e a
- class Monad m => MonadError e m | m -> e where
  - throwError :: e -> m a
  - catchError :: m a -> (e -> m a) -> m a
- throwError :: MonadError e m => forall a. e -> m a
- catchError :: MonadError e m => forall a. m a -> (e -> m a) -> m a

# 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

MonadReader r m => MonadReader r (ExceptT e m) |
FilterMonad a m => FilterMonad a (ExceptT e m) |
WebMonad a m => WebMonad a (ExceptT e m) |
Monad m => MonadError e (ExceptT e m) |
MonadState s m => MonadState s (ExceptT e m) |
MonadBaseControl b m => MonadBaseControl b (ExceptT e m) |
MonadBase b m => MonadBase b (ExceptT e m) |
MonadTrans (ExceptT e) |
MonadTransControl (ExceptT e) |
Monad m => Monad (ExceptT e m) |
Functor m => Functor (ExceptT e m) |
MonadFix m => MonadFix (ExceptT e m) |
(Functor m, Monad m) => Applicative (ExceptT e m) |
Foldable f => Foldable (ExceptT e f) |
Traversable f => Traversable (ExceptT e f) |
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) |
(Monad m, Monoid e) => MonadPlus (ExceptT e m) |
MonadIO m => MonadIO (ExceptT e m) |
(Happstack m, Monoid e) => Happstack (ExceptT e m) |
(Monad m, HasRqData m) => HasRqData (ExceptT e m) |
ServerMonad m => ServerMonad (ExceptT e m) |
(Eq e, Eq1 m) => Eq1 (ExceptT e m) |
(Ord e, Ord1 m) => Ord1 (ExceptT e m) |
(Read e, Read1 m) => Read1 (ExceptT e m) |
(Show e, Show1 m) => Show1 (ExceptT e m) |
PrimMonad m => PrimMonad (ExceptT e m) |
MonadResource m => MonadResource (ExceptT e m) |
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) |
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) |
(Read e, Read1 m, Read a) => Read (ExceptT e m a) |
(Show e, Show1 m, Show a) => Show (ExceptT e m a) |
type StT (ExceptT e) a = Either e a |
type PrimState (ExceptT e m) = PrimState m |
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 continies after an error and collects all the errors, see `Errors`.

class Error a where Source

Minimal complete definition

Nothing

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

The strategy of combining computations that can throw exceptions by bypassing bound functions from the point an exception is thrown to the point that it is handled.

Is parameterized over the type of error information and the monad type constructor. It is common to use ``Either` String` as the monad type constructor for an error monad in which error descriptions take the form of strings. In that case and many other common cases the resulting monad is already defined as an instance of the `MonadError` class. You can also define your own error type and/or use a monad type constructor other than ``Either` `String`` or ``Either` `IOError``. In these cases you will have to explicitly define instances of the `Error` and/or `MonadError` classes.

Methods

throwError :: e -> m a

Is used within a monadic computation to begin exception processing.

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

A handler function to handle previous errors and return to normal execution. A common idiom is:

    do { action1; action2; action3 } `catchError` handler

where the `action` functions can call `throwError`. Note that `handler` and the do-block must have the same return type.

Instances

MonadError IOException IO |
MonadError e m => MonadError e (ResourceT m) |
MonadError e m => MonadError e (WebT m) |
(Monad m, MonadError e m) => MonadError e (ServerPartT m) |
MonadError e m => MonadError e (MaybeT m) |
MonadError e m => MonadError e (ListT m) |
MonadError e m => MonadError e (IdentityT m) |
MonadError e (Either e) |
(Monoid w, MonadError e m) => MonadError e (WriterT w m) |
(Monoid w, MonadError e m) => MonadError e (WriterT w m) |
MonadError e m => MonadError e (StateT s m) |
MonadError e m => MonadError e (StateT s m) |
MonadError e m => MonadError e (ReaderT r m) |
Monad m => MonadError e (ExceptT e m) |
(Monad m, Error e) => MonadError e (ErrorT e m) |
MonadError e m => MonadError e (ParsecT s u m) |
(Monoid w, MonadError e m) => MonadError e (RWST r w s m) |
(Monoid w, MonadError e m) => MonadError e (RWST r w s m) |

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

Is used within a monadic computation to begin exception processing.

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

A handler function to handle previous errors and return to normal execution. A common idiom is:

    do { action1; action2; action3 } `catchError` handler

where the `action` functions can call `throwError`. Note that `handler` and the do-block must have the same return type.