Control.Monad.Trans.Error

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.

The ErrorT monad transformer

class Error a where

An exception to be thrown.

Minimal complete definition: noMsg or strMsg.

Minimal complete definition

Nothing

Methods

noMsg :: a

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

strMsg :: String -> a

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

Instances

Error IOException

Defined in Control.Monad.Trans.Error

Methods

noMsg :: IOException

strMsg :: String -> IOException

ErrorList a => Error [a]

A string can be thrown as an error.

Defined in Control.Monad.Trans.Error

Methods

noMsg :: [a]

strMsg :: String -> [a]

class ErrorList a where

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

Methods

listMsg :: String -> [a]

Instances

ErrorList Char

Defined in Control.Monad.Trans.Error

Methods

listMsg :: String -> [Char]

newtype ErrorT e m a

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)

Defined in Control.Monad.Trans.Error

Methods

lift :: Monad m => m a -> ErrorT e m a

(Monad m, Error e) => Monad (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

(>>=) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b

(>>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b

return :: a -> ErrorT e m a

fail :: String -> ErrorT e m a

Functor m => Functor (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

fmap :: (a -> b) -> ErrorT e m a -> ErrorT e m b

(<$) :: a -> ErrorT e m b -> ErrorT e m a

(MonadFix m, Error e) => MonadFix (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

mfix :: (a -> ErrorT e m a) -> ErrorT e m a

(Monad m, Error e) => MonadFail (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

fail :: String -> ErrorT e m a

(Functor m, Monad m) => Applicative (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

pure :: a -> ErrorT e m a

(<*>) :: ErrorT e m (a -> b) -> ErrorT e m a -> ErrorT e m b

liftA2 :: (a -> b -> c) -> ErrorT e m a -> ErrorT e m b -> ErrorT e m c

(*>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b

(<*) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m a

Foldable f => Foldable (ErrorT e f)

Defined in Control.Monad.Trans.Error

Methods

fold :: Monoid m => ErrorT e f m -> m

foldMap :: Monoid m => (a -> m) -> ErrorT e f a -> m

foldr :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldr' :: (a -> b -> b) -> b -> ErrorT e f a -> b

foldl :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldl' :: (b -> a -> b) -> b -> ErrorT e f a -> b

foldr1 :: (a -> a -> a) -> ErrorT e f a -> a

foldl1 :: (a -> a -> a) -> ErrorT e f a -> a

toList :: ErrorT e f a -> [a]

null :: ErrorT e f a -> Bool

length :: ErrorT e f a -> Int

elem :: Eq a => a -> ErrorT e f a -> Bool

maximum :: Ord a => ErrorT e f a -> a

minimum :: Ord a => ErrorT e f a -> a

sum :: Num a => ErrorT e f a -> a

product :: Num a => ErrorT e f a -> a

Traversable f => Traversable (ErrorT e f)

Defined in Control.Monad.Trans.Error

Methods

traverse :: Applicative f0 => (a -> f0 b) -> ErrorT e f a -> f0 (ErrorT e f b)

sequenceA :: Applicative f0 => ErrorT e f (f0 a) -> f0 (ErrorT e f a)

mapM :: Monad m => (a -> m b) -> ErrorT e f a -> m (ErrorT e f b)

sequence :: Monad m => ErrorT e f (m a) -> m (ErrorT e f a)

Contravariant m => Contravariant (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

contramap :: (a -> b) -> ErrorT e m b -> ErrorT e m a

(>$) :: b -> ErrorT e m b -> ErrorT e m a

(Eq e, Eq1 m) => Eq1 (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftEq :: (a -> b -> Bool) -> ErrorT e m a -> ErrorT e m b -> Bool

(Ord e, Ord1 m) => Ord1 (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftCompare :: (a -> b -> Ordering) -> ErrorT e m a -> ErrorT e m b -> Ordering

(Read e, Read1 m) => Read1 (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ErrorT e m a)

liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ErrorT e m a]

liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ErrorT e m a)

liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ErrorT e m a]

(Show e, Show1 m) => Show1 (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ErrorT e m a -> ShowS

liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ErrorT e m a] -> ShowS

(Error e, MonadIO m) => MonadIO (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

liftIO :: IO a -> ErrorT e m a

(Functor m, Monad m, Error e) => Alternative (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

empty :: ErrorT e m a

(<|>) :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

some :: ErrorT e m a -> ErrorT e m [a]

many :: ErrorT e m a -> ErrorT e m [a]

(Monad m, Error e) => MonadPlus (ErrorT e m)

Defined in Control.Monad.Trans.Error

Methods

mzero :: ErrorT e m a

mplus :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a

(Eq e, Eq1 m, Eq a) => Eq (ErrorT e m a)

Defined in Control.Monad.Trans.Error

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)

Defined in Control.Monad.Trans.Error

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)

Defined in Control.Monad.Trans.Error

Methods

readsPrec :: Int -> ReadS (ErrorT e m a)

readList :: ReadS [ErrorT e m a]

readPrec :: ReadPrec (ErrorT e m a)

readListPrec :: ReadPrec [ErrorT e m a]

(Show e, Show1 m, Show a) => Show (ErrorT e m a)

Defined in Control.Monad.Trans.Error

Methods

showsPrec :: Int -> ErrorT e m a -> ShowS

show :: ErrorT e m a -> String

showList :: [ErrorT e m a] -> ShowS

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

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

Signal an error value e.

• runErrorT (throwError e) = return (Left e)

• throwError e >>= m = throwError e

catchError

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

Lift a callCC operation to the new monad.

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

Lift a listen operation to the new monad.

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

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)

Methods

empty :: Either e a

(<|>) :: Either e a -> Either e a -> Either e a

some :: Either e a -> Either e [a]

many :: Either e a -> Either e [a]

Error e => MonadPlus (Either e)

Methods

mzero :: Either e a

mplus :: Either e a -> Either e a -> Either e a