Copyright	(c) Michael Weber <michael.weber@post.rwth-aachen.de> 2001 (c) Jeff Newbern 2003-2006 (c) Andriy Palamarchuk 2006
License	BSD-style (see the file LICENSE)
Maintainer	R.Paterson@city.ac.uk
Stability	experimental
Portability	portable
Safe Haskell	Safe
Language	Haskell98

Control.Monad.Trans.Error

Contents

The ErrorT monad transformer
Error operations
Lifting other operations
Examples
Orphan instances

Description

Deprecated: Use Control.Monad.Trans.Except instead

This monad transformer adds the ability to fail or throw exceptions to a monad.

A sequence of actions succeeds, producing a value, only if all the actions in the sequence are successful. If one fails with an error, the rest of the sequence is skipped and the composite action fails with that error.

If the value of the error is not required, the variant in Control.Monad.Trans.Maybe may be used instead.

Note: This module will be removed in a future release. Instead, use Control.Monad.Trans.Except, which does not restrict the exception type, and also includes a base exception monad.

Synopsis

class Error a where
class ErrorList a where
newtype ErrorT e m a = ErrorT {
- runErrorT :: m (Either e a)
}
mapErrorT :: (m (Either e a) -> n (Either e' b)) -> ErrorT e m a -> ErrorT e' n b
throwError :: Monad m => e -> ErrorT e m a
catchError :: Monad m => ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a
liftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ErrorT e m) a b
liftListen :: Monad m => Listen w m (Either e a) -> Listen w (ErrorT e m) a
liftPass :: Monad m => Pass w m (Either e a) -> Pass w (ErrorT e m) a

The ErrorT monad transformer

class Error a where Source #

An exception to be thrown.

Minimal complete definition: noMsg or strMsg.

Methods

noMsg :: a Source #

Creates an exception without a message. The default implementation is strMsg "".

strMsg :: String -> a Source #

Creates an exception with a message. The default implementation of strMsg s is noMsg.

Instances

Error IOException #
Instance details Methods noMsg :: IOException Source # strMsg :: String -> IOException Source #
ErrorList a => Error [a] #	A string can be thrown as an error.
Instance details Methods noMsg :: [a] Source # strMsg :: String -> [a] Source #

class ErrorList a where Source #

Workaround so that we can have a Haskell 98 instance Error String.

Minimal complete definition

listMsg

Methods

listMsg :: String -> [a] Source #

Instances

ErrorList Char #
Instance details Methods listMsg :: String -> [Char] Source #

newtype ErrorT e m a Source #

The error monad transformer. It can be used to add error handling to other monads.

The ErrorT Monad structure is parameterized over two things:

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

The return function yields a successful computation, while >>= sequences two subcomputations, failing on the first error.

Constructors

ErrorT
Fields runErrorT :: m (Either e a)

Instances

MonadTrans (ErrorT e) #
Instance details Methods lift :: Monad m => m a -> ErrorT e m a Source #
(Monad m, Error e) => Monad (ErrorT e m) #
Instance details Methods (>>=) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b Source # (>>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b Source # return :: a -> ErrorT e m a Source # fail :: String -> ErrorT e m a Source #
Functor m => Functor (ErrorT e m) #
Instance details Methods fmap :: (a -> b) -> ErrorT e m a -> ErrorT e m b Source # (<$) :: a -> ErrorT e m b -> ErrorT e m a Source #
(MonadFix m, Error e) => MonadFix (ErrorT e m) #
Instance details Methods mfix :: (a -> ErrorT e m a) -> ErrorT e m a Source #
(Monad m, Error e) => MonadFail (ErrorT e m) #
Instance details Methods fail :: String -> ErrorT e m a Source #
(Functor m, Monad m) => Applicative (ErrorT e m) #
Instance details Methods pure :: a -> ErrorT e m a Source # (<>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b Source # liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c Source # (>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b Source # (<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a Source #
Foldable f => Foldable (ErrorT e f) #
Instance details Methods fold :: Monoid m => ErrorT e f m -> m Source # foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m Source # foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b Source # foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b Source # foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b Source # foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b Source # foldr1 :: (a -> a -> a) -> ErrorT e f a -> a Source # foldl1 :: (a -> a -> a) -> ErrorT e f a -> a Source # toList :: ErrorT e f a -> [a] Source # null :: ErrorT e f a -> Bool Source # length :: ErrorT e f a -> Int Source # elem :: Eq a => a -> ErrorT e f a -> Bool Source # maximum :: Ord a => ErrorT e f a -> a Source # minimum :: Ord a => ErrorT e f a -> a Source # sum :: Num a => ErrorT e f a -> a Source # product :: Num a => ErrorT e f a -> a Source #
Traversable f => Traversable (ErrorT e f) #
Instance details Methods traverse :: Applicative f0 => (a -> f0 b) -> ErrorT e f a -> f0 (ErrorT e f b) Source # sequenceA :: Applicative f0 => ErrorT e f (f0 a) -> f0 (ErrorT e f a) Source # mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b) Source # sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a) Source #
(Eq e, Eq1 m) => Eq1 (ErrorT e m) #
Instance details Methods liftEq :: (a -> b -> Bool) -> ErrorT e m a -> ErrorT e m b -> Bool Source #
(Ord e, Ord1 m) => Ord1 (ErrorT e m) #
Instance details Methods liftCompare :: (a -> b -> Ordering) -> ErrorT e m a -> ErrorT e m b -> Ordering Source #
(Read e, Read1 m) => Read1 (ErrorT e m) #
Instance details Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ErrorT e m a) Source # liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ErrorT e m a] Source # liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ErrorT e m a) Source # liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ErrorT e m a] Source #
(Show e, Show1 m) => Show1 (ErrorT e m) #
Instance details Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ErrorT e m a -> ShowS Source # liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ErrorT e m a] -> ShowS Source #
(Error e, MonadIO m) => MonadIO (ErrorT e m) #
Instance details Methods liftIO :: IO a -> ErrorT e m a Source #
(Functor m, Monad m, Error e) => Alternative (ErrorT e m) #
Instance details Methods empty :: ErrorT e m a Source # (<\|>) :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a Source # some :: ErrorT e m a -> ErrorT e m [a] Source # many :: ErrorT e m a -> ErrorT e m [a] Source #
(Monad m, Error e) => MonadPlus (ErrorT e m) #
Instance details Methods mzero :: ErrorT e m a Source # mplus :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a Source #
(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a) #
Instance details Methods (==) :: ErrorT e m a -> ErrorT e m a -> Bool # (/=) :: ErrorT e m a -> ErrorT e m a -> Bool #
(Ord e, Ord1 m, Ord a) => Ord (ErrorT e m a) #
Instance details Methods compare :: ErrorT e m a -> ErrorT e m a -> Ordering # (<) :: ErrorT e m a -> ErrorT e m a -> Bool # (<=) :: ErrorT e m a -> ErrorT e m a -> Bool # (>) :: ErrorT e m a -> ErrorT e m a -> Bool # (>=) :: ErrorT e m a -> ErrorT e m a -> Bool # max :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a # min :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a #
(Read e, Read1 m, Read a) => Read (ErrorT e m a) #
Instance details Methods readsPrec :: Int -> ReadS (ErrorT e m a) Source # readList :: ReadS [ErrorT e m a] Source # readPrec :: ReadPrec (ErrorT e m a) Source # readListPrec :: ReadPrec [ErrorT e m a] Source #
(Show e, Show1 m, Show a) => Show (ErrorT e m a) #
Instance details Methods showsPrec :: Int -> ErrorT e m a -> ShowS Source # show :: ErrorT e m a -> String Source # showList :: [ErrorT e m a] -> ShowS Source #

mapErrorT :: (m (Either e a) -> n (Either e' b)) -> ErrorT e m a -> ErrorT e' n b Source #

Map the unwrapped computation using the given function.

runErrorT (mapErrorT f m) = f (runErrorT m)

Error operations

throwError :: Monad m => e -> ErrorT e m a Source #

Signal an error value e.

runErrorT (throwError e) = return (Left e)

```
throwError e >>= m = throwError e
```

catchError Source #

Arguments

:: Monad m
=> ErrorT e m a	the inner computation
-> (e -> ErrorT e m a)	a handler for errors in the inner computation
-> ErrorT e m a

Handle an error.

```
catchError h (lift m) = lift m
```
```
catchError h (throwError e) = h e
```

Lifting other operations

liftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ErrorT e m) a b Source #

Lift a callCC operation to the new monad.

liftListen :: Monad m => Listen w m (Either e a) -> Listen w (ErrorT e m) a Source #

Lift a listen operation to the new monad.

liftPass :: Monad m => Pass w m (Either e a) -> Pass w (ErrorT e m) a Source #

Lift a pass operation to the new monad.

Examples

Wrapping an IO action that can throw an error e:

type ErrorWithIO e a = ErrorT e IO a
==> ErrorT (IO (Either e a))

An IO monad wrapped in StateT inside of ErrorT:

type ErrorAndStateWithIO e s a = ErrorT e (StateT s IO) a
==> ErrorT (StateT s IO (Either e a))
==> ErrorT (StateT (s -> IO (Either e a,s)))

Orphan instances

Error e => Alternative (Either e) #
Instance details Methods empty :: Either e a Source # (<\|>) :: Either e a -> Either e a -> Either e a Source # some :: Either e a -> Either e [a] Source # many :: Either e a -> Either e [a] Source #
Error e => MonadPlus (Either e) #
Instance details Methods mzero :: Either e a Source # mplus :: Either e a -> Either e a -> Either e a Source #