module Control.Error.Safe (
tailErr,
initErr,
headErr,
lastErr,
minimumErr,
maximumErr,
foldr1Err,
foldl1Err,
foldl1Err',
atErr,
readErr,
assertErr,
tryTail,
tryInit,
tryHead,
tryLast,
tryMinimum,
tryMaximum,
tryFoldr1,
tryFoldl1,
tryFoldl1',
tryAt,
tryRead,
tryAssert,
) where
import Control.Error.Util
import Control.Monad.Trans.Either
import Safe
tailErr :: e -> [a] -> Either e [a]
tailErr e = note e . tailMay
initErr :: e -> [a] -> Either e [a]
initErr e = note e . initMay
headErr :: e -> [a] -> Either e a
headErr e = note e . headMay
lastErr :: e -> [a] -> Either e a
lastErr e = note e . lastMay
minimumErr :: (Ord a) => e -> [a] -> Either e a
minimumErr e = note e . minimumMay
maximumErr :: (Ord a) => e -> [a] -> Either e a
maximumErr e = note e . maximumMay
foldr1Err :: e -> (a -> a -> a) -> [a] -> Either e a
foldr1Err e step xs = note e $ foldr1May step xs
foldl1Err :: e -> (a -> a -> a) -> [a] -> Either e a
foldl1Err e step xs = note e $ foldl1May step xs
foldl1Err' :: e -> (a -> a -> a) -> [a] -> Either e a
foldl1Err' e step xs = note e $ foldl1May' step xs
atErr :: e -> [a] -> Int -> Either e a
atErr e xs n = note e $ atMay xs n
readErr :: (Read a) => e -> String -> Either e a
readErr e = note e . readMay
assertErr :: e -> Bool -> a -> Either e a
assertErr e p a = if p then Right a else Left e
tryTail :: (Monad m) => e -> [a] -> EitherT e m [a]
tryTail e xs = liftEither $ tailErr e xs
tryInit :: (Monad m) => e -> [a] -> EitherT e m [a]
tryInit e xs = liftEither $ initErr e xs
tryHead :: (Monad m) => e -> [a] -> EitherT e m a
tryHead e xs = liftEither $ headErr e xs
tryLast :: (Monad m) => e -> [a] -> EitherT e m a
tryLast e xs = liftEither $ lastErr e xs
tryMinimum :: (Monad m, Ord a) => e -> [a] -> EitherT e m a
tryMinimum e xs = liftEither $ maximumErr e xs
tryMaximum :: (Monad m, Ord a) => e -> [a] -> EitherT e m a
tryMaximum e xs = liftEither $ maximumErr e xs
tryFoldr1 :: (Monad m) => e -> (a -> a -> a) -> [a] -> EitherT e m a
tryFoldr1 e step xs = liftEither $ foldr1Err e step xs
tryFoldl1 :: (Monad m) => e -> (a -> a -> a) -> [a] -> EitherT e m a
tryFoldl1 e step xs = liftEither $ foldl1Err e step xs
tryFoldl1' :: (Monad m) => e -> (a -> a -> a) -> [a] -> EitherT e m a
tryFoldl1' e step xs = liftEither $ foldl1Err' e step xs
tryAt :: (Monad m) => e -> [a] -> Int -> EitherT e m a
tryAt e xs n = liftEither $ atErr e xs n
tryRead :: (Monad m, Read a) => e -> String -> EitherT e m a
tryRead e str = liftEither $ readErr e str
tryAssert :: (Monad m) => e -> Bool -> a -> EitherT e m a
tryAssert e p a = liftEither $ assertErr e p a