Control.Error.Safe

This module extends the safe library's functions with corresponding versions compatible with Either and ExceptT, and also provides a few Maybe-compatible functions missing from safe.

I suffix the Either-compatible functions with Err and prefix the ExceptT-compatible functions with try.

Note that this library re-exports the Maybe compatible functions from safe in the Control.Error module, so they are not provided here.

The 'Z'-suffixed functions generalize the Maybe functions to also work with anything that implements MonadPlus, including:

• Lists
• Most parsers
• ExceptT (if the left value is a Monoid)

Maybe-compatible functions

assertMay :: Bool -> Maybe ()

An assertion that fails in the Maybe monad

rightMay :: Either e a -> Maybe a

A fromRight that fails in the Maybe monad

Either-compatible functions

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

A tail that fails in the Either monad

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

An init that fails in the Either monad

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

A head that fails in the Either monad

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

A last that fails in the Either monad

minimumErr :: Ord a => e -> [a] -> Either e a

A minimum that fails in the Either monad

maximumErr :: Ord a => e -> [a] -> Either e a

A maximum that fails in the Either monad

foldr1Err :: e -> (a -> a -> a) -> [a] -> Either e a

A foldr1 that fails in the Either monad

foldl1Err :: e -> (a -> a -> a) -> [a] -> Either e a

A foldl1 that fails in the Either monad

foldl1Err' :: e -> (a -> a -> a) -> [a] -> Either e a

A foldl1' that fails in the Either monad

atErr :: e -> [a] -> Int -> Either e a

A (!!) that fails in the Either monad

readErr :: Read a => e -> String -> Either e a

A read that fails in the Either monad

assertErr :: e -> Bool -> Either e ()

An assertion that fails in the Either monad

justErr :: e -> Maybe a -> Either e a

A fromJust that fails in the Either monad

ExceptT-compatible functions

tryTail :: Monad m => e -> [a] -> ExceptT e m [a]

A tail that fails in the ExceptT monad

tryInit :: Monad m => e -> [a] -> ExceptT e m [a]

An init that fails in the ExceptT monad

tryHead :: Monad m => e -> [a] -> ExceptT e m a

A head that fails in the ExceptT monad

tryLast :: Monad m => e -> [a] -> ExceptT e m a

A last that fails in the ExceptT monad

tryMinimum :: (Monad m, Ord a) => e -> [a] -> ExceptT e m a

A minimum that fails in the ExceptT monad

tryMaximum :: (Monad m, Ord a) => e -> [a] -> ExceptT e m a

A maximum that fails in the ExceptT monad

tryFoldr1 :: Monad m => e -> (a -> a -> a) -> [a] -> ExceptT e m a

A foldr1 that fails in the ExceptT monad

tryFoldl1 :: Monad m => e -> (a -> a -> a) -> [a] -> ExceptT e m a

A foldl1 that fails in the ExceptT monad

tryFoldl1' :: Monad m => e -> (a -> a -> a) -> [a] -> ExceptT e m a

A foldl1' that fails in the ExceptT monad

tryAt :: Monad m => e -> [a] -> Int -> ExceptT e m a

A (!!) that fails in the ExceptT monad

tryRead :: (Monad m, Read a) => e -> String -> ExceptT e m a

A read that fails in the ExceptT monad

tryAssert :: Monad m => e -> Bool -> ExceptT e m ()

An assertion that fails in the ExceptT monad

tryJust :: Monad m => e -> Maybe a -> ExceptT e m a

A fromJust that fails in the ExceptT monad

tryRight :: Monad m => Either e a -> ExceptT e m a

A fromRight that fails in the ExceptT monad

MonadPlus-compatible functions

tailZ :: MonadPlus m => [a] -> m [a]

A tail that fails using mzero

initZ :: MonadPlus m => [a] -> m [a]

An init that fails using mzero

headZ :: MonadPlus m => [a] -> m a

A head that fails using mzero

lastZ :: MonadPlus m => [a] -> m a

A last that fails using mzero

minimumZ :: MonadPlus m => Ord a => [a] -> m a

A minimum that fails using mzero

maximumZ :: MonadPlus m => Ord a => [a] -> m a

A maximum that fails using mzero

foldr1Z :: MonadPlus m => (a -> a -> a) -> [a] -> m a

A foldr1 that fails using mzero

foldl1Z :: MonadPlus m => (a -> a -> a) -> [a] -> m a

A foldl1 that fails using mzero

foldl1Z' :: MonadPlus m => (a -> a -> a) -> [a] -> m a

A foldl1' that fails using mzero

atZ :: MonadPlus m => [a] -> Int -> m a

A (!!) that fails using mzero

readZ :: MonadPlus m => Read a => String -> m a

A read that fails using mzero

assertZ :: MonadPlus m => Bool -> m ()

An assertion that fails using mzero

justZ :: MonadPlus m => Maybe a -> m a

A fromJust that fails using mzero

rightZ :: MonadPlus m => Either e a -> m a

A fromRight that fails using mzero