module Control.Error.Safe (
assertMay,
rightMay,
tailErr,
initErr,
headErr,
lastErr,
minimumErr,
maximumErr,
foldr1Err,
foldl1Err,
foldl1Err',
atErr,
readErr,
assertErr,
justErr,
tryTail,
tryInit,
tryHead,
tryLast,
tryMinimum,
tryMaximum,
tryFoldr1,
tryFoldl1,
tryFoldl1',
tryAt,
tryRead,
tryAssert,
tryJust,
tryRight,
tailZ,
initZ,
headZ,
lastZ,
minimumZ,
maximumZ,
foldr1Z,
foldl1Z,
foldl1Z',
atZ,
readZ,
assertZ,
justZ,
rightZ
) where
import Control.Error.Util (note, hoistEither)
import Control.Monad (MonadPlus(mzero))
import Control.Monad.Trans.Except (ExceptT)
import qualified Safe as S
assertMay :: Bool -> Maybe ()
assertMay :: Bool -> Maybe ()
assertMay = forall (m :: * -> *). MonadPlus m => Bool -> m ()
assertZ
rightMay :: Either e a -> Maybe a
rightMay :: forall e a. Either e a -> Maybe a
rightMay = forall (m :: * -> *) e a. MonadPlus m => Either e a -> m a
rightZ
tailErr :: e -> [a] -> Either e [a]
tailErr :: forall e a. e -> [a] -> Either e [a]
tailErr e
e = forall a b. a -> Maybe b -> Either a b
note e
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe [a]
S.tailMay
initErr :: e -> [a] -> Either e [a]
initErr :: forall e a. e -> [a] -> Either e [a]
initErr e
e = forall a b. a -> Maybe b -> Either a b
note e
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe [a]
S.initMay
headErr :: e -> [a] -> Either e a
e
e = forall a b. a -> Maybe b -> Either a b
note e
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe a
S.headMay
lastErr :: e -> [a] -> Either e a
lastErr :: forall e a. e -> [a] -> Either e a
lastErr e
e = forall a b. a -> Maybe b -> Either a b
note e
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe a
S.lastMay
minimumErr :: (Ord a) => e -> [a] -> Either e a
minimumErr :: forall a e. Ord a => e -> [a] -> Either e a
minimumErr e
e = forall a b. a -> Maybe b -> Either a b
note e
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> Maybe a
S.minimumMay
maximumErr :: (Ord a) => e -> [a] -> Either e a
maximumErr :: forall a e. Ord a => e -> [a] -> Either e a
maximumErr e
e = forall a b. a -> Maybe b -> Either a b
note e
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> Maybe a
S.maximumMay
foldr1Err :: e -> (a -> a -> a) -> [a] -> Either e a
foldr1Err :: forall e a. e -> (a -> a -> a) -> [a] -> Either e a
foldr1Err e
e a -> a -> a
step [a]
xs = forall a b. a -> Maybe b -> Either a b
note e
e forall a b. (a -> b) -> a -> b
$ forall a. (a -> a -> a) -> [a] -> Maybe a
S.foldr1May a -> a -> a
step [a]
xs
foldl1Err :: e -> (a -> a -> a) -> [a] -> Either e a
foldl1Err :: forall e a. e -> (a -> a -> a) -> [a] -> Either e a
foldl1Err e
e a -> a -> a
step [a]
xs = forall a b. a -> Maybe b -> Either a b
note e
e forall a b. (a -> b) -> a -> b
$ forall a. (a -> a -> a) -> [a] -> Maybe a
S.foldl1May a -> a -> a
step [a]
xs
foldl1Err' :: e -> (a -> a -> a) -> [a] -> Either e a
foldl1Err' :: forall e a. e -> (a -> a -> a) -> [a] -> Either e a
foldl1Err' e
e a -> a -> a
step [a]
xs = forall a b. a -> Maybe b -> Either a b
note e
e forall a b. (a -> b) -> a -> b
$ forall a. (a -> a -> a) -> [a] -> Maybe a
S.foldl1May' a -> a -> a
step [a]
xs
atErr :: e -> [a] -> Int -> Either e a
atErr :: forall e a. e -> [a] -> Int -> Either e a
atErr e
e [a]
xs Int
n = forall a b. a -> Maybe b -> Either a b
note e
e forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Int -> Maybe a
S.atMay [a]
xs Int
n
readErr :: (Read a) => e -> String -> Either e a
readErr :: forall a e. Read a => e -> String -> Either e a
readErr e
e = forall a b. a -> Maybe b -> Either a b
note e
e forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Read a => String -> Maybe a
S.readMay
assertErr :: e -> Bool -> Either e ()
assertErr :: forall e. e -> Bool -> Either e ()
assertErr e
e Bool
p = if Bool
p then forall a b. b -> Either a b
Right () else forall a b. a -> Either a b
Left e
e
justErr :: e -> Maybe a -> Either e a
justErr :: forall a b. a -> Maybe b -> Either a b
justErr e
e = forall b a. b -> (a -> b) -> Maybe a -> b
maybe (forall a b. a -> Either a b
Left e
e) forall a b. b -> Either a b
Right
tryTail :: (Monad m) => e -> [a] -> ExceptT e m [a]
tryTail :: forall (m :: * -> *) e a. Monad m => e -> [a] -> ExceptT e m [a]
tryTail e
e [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e a. e -> [a] -> Either e [a]
tailErr e
e [a]
xs
tryInit :: (Monad m) => e -> [a] -> ExceptT e m [a]
tryInit :: forall (m :: * -> *) e a. Monad m => e -> [a] -> ExceptT e m [a]
tryInit e
e [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e a. e -> [a] -> Either e [a]
initErr e
e [a]
xs
tryHead :: (Monad m) => e -> [a] -> ExceptT e m a
tryHead :: forall (m :: * -> *) e a. Monad m => e -> [a] -> ExceptT e m a
tryHead e
e [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e a. e -> [a] -> Either e a
headErr e
e [a]
xs
tryLast :: (Monad m) => e -> [a] -> ExceptT e m a
tryLast :: forall (m :: * -> *) e a. Monad m => e -> [a] -> ExceptT e m a
tryLast e
e [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e a. e -> [a] -> Either e a
lastErr e
e [a]
xs
tryMinimum :: (Monad m, Ord a) => e -> [a] -> ExceptT e m a
tryMinimum :: forall (m :: * -> *) a e.
(Monad m, Ord a) =>
e -> [a] -> ExceptT e m a
tryMinimum e
e [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall a e. Ord a => e -> [a] -> Either e a
maximumErr e
e [a]
xs
tryMaximum :: (Monad m, Ord a) => e -> [a] -> ExceptT e m a
tryMaximum :: forall (m :: * -> *) a e.
(Monad m, Ord a) =>
e -> [a] -> ExceptT e m a
tryMaximum e
e [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall a e. Ord a => e -> [a] -> Either e a
maximumErr e
e [a]
xs
tryFoldr1 :: (Monad m) => e -> (a -> a -> a) -> [a] -> ExceptT e m a
tryFoldr1 :: forall (m :: * -> *) e a.
Monad m =>
e -> (a -> a -> a) -> [a] -> ExceptT e m a
tryFoldr1 e
e a -> a -> a
step [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e a. e -> (a -> a -> a) -> [a] -> Either e a
foldr1Err e
e a -> a -> a
step [a]
xs
tryFoldl1 :: (Monad m) => e -> (a -> a -> a) -> [a] -> ExceptT e m a
tryFoldl1 :: forall (m :: * -> *) e a.
Monad m =>
e -> (a -> a -> a) -> [a] -> ExceptT e m a
tryFoldl1 e
e a -> a -> a
step [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e a. e -> (a -> a -> a) -> [a] -> Either e a
foldl1Err e
e a -> a -> a
step [a]
xs
tryFoldl1' :: (Monad m) => e -> (a -> a -> a) -> [a] -> ExceptT e m a
tryFoldl1' :: forall (m :: * -> *) e a.
Monad m =>
e -> (a -> a -> a) -> [a] -> ExceptT e m a
tryFoldl1' e
e a -> a -> a
step [a]
xs = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e a. e -> (a -> a -> a) -> [a] -> Either e a
foldl1Err' e
e a -> a -> a
step [a]
xs
tryAt :: (Monad m) => e -> [a] -> Int -> ExceptT e m a
tryAt :: forall (m :: * -> *) e a.
Monad m =>
e -> [a] -> Int -> ExceptT e m a
tryAt e
e [a]
xs Int
n = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e a. e -> [a] -> Int -> Either e a
atErr e
e [a]
xs Int
n
tryRead :: (Monad m, Read a) => e -> String -> ExceptT e m a
tryRead :: forall (m :: * -> *) a e.
(Monad m, Read a) =>
e -> String -> ExceptT e m a
tryRead e
e String
str = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall a e. Read a => e -> String -> Either e a
readErr e
e String
str
tryAssert :: (Monad m) => e -> Bool -> ExceptT e m ()
tryAssert :: forall (m :: * -> *) e. Monad m => e -> Bool -> ExceptT e m ()
tryAssert e
e Bool
p = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall e. e -> Bool -> Either e ()
assertErr e
e Bool
p
tryJust :: (Monad m) => e -> Maybe a -> ExceptT e m a
tryJust :: forall (m :: * -> *) e a. Monad m => e -> Maybe a -> ExceptT e m a
tryJust e
e Maybe a
m = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither forall a b. (a -> b) -> a -> b
$ forall a b. a -> Maybe b -> Either a b
justErr e
e Maybe a
m
tryRight :: (Monad m) => Either e a -> ExceptT e m a
tryRight :: forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
tryRight = forall (m :: * -> *) e a. Monad m => Either e a -> ExceptT e m a
hoistEither
tailZ :: (MonadPlus m) => [a] -> m [a]
tailZ :: forall (m :: * -> *) a. MonadPlus m => [a] -> m [a]
tailZ = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe [a]
S.tailMay
initZ :: (MonadPlus m) => [a] -> m [a]
initZ :: forall (m :: * -> *) a. MonadPlus m => [a] -> m [a]
initZ = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe [a]
S.initMay
headZ :: (MonadPlus m) => [a] -> m a
headZ :: forall (m :: * -> *) a. MonadPlus m => [a] -> m a
headZ = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe a
S.headMay
lastZ :: (MonadPlus m) => [a] -> m a
lastZ :: forall (m :: * -> *) a. MonadPlus m => [a] -> m a
lastZ = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. [a] -> Maybe a
S.lastMay
minimumZ :: (MonadPlus m) => (Ord a) => [a] -> m a
minimumZ :: forall (m :: * -> *) a. (MonadPlus m, Ord a) => [a] -> m a
minimumZ = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> Maybe a
S.minimumMay
maximumZ :: (MonadPlus m) => (Ord a) => [a] -> m a
maximumZ :: forall (m :: * -> *) a. (MonadPlus m, Ord a) => [a] -> m a
maximumZ = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Ord a => [a] -> Maybe a
S.maximumMay
foldr1Z :: (MonadPlus m) => (a -> a -> a) -> [a] -> m a
foldr1Z :: forall (m :: * -> *) a. MonadPlus m => (a -> a -> a) -> [a] -> m a
foldr1Z a -> a -> a
step [a]
xs = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. (a -> a -> a) -> [a] -> Maybe a
S.foldr1May a -> a -> a
step [a]
xs
foldl1Z :: (MonadPlus m) => (a -> a -> a) -> [a] -> m a
foldl1Z :: forall (m :: * -> *) a. MonadPlus m => (a -> a -> a) -> [a] -> m a
foldl1Z a -> a -> a
step [a]
xs = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. (a -> a -> a) -> [a] -> Maybe a
S.foldl1May a -> a -> a
step [a]
xs
foldl1Z' :: (MonadPlus m) => (a -> a -> a) -> [a] -> m a
foldl1Z' :: forall (m :: * -> *) a. MonadPlus m => (a -> a -> a) -> [a] -> m a
foldl1Z' a -> a -> a
step [a]
xs = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. (a -> a -> a) -> [a] -> Maybe a
S.foldl1May' a -> a -> a
step [a]
xs
atZ :: (MonadPlus m) => [a] -> Int -> m a
atZ :: forall (m :: * -> *) a. MonadPlus m => [a] -> Int -> m a
atZ [a]
xs Int
n = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall a. [a] -> Int -> Maybe a
S.atMay [a]
xs Int
n
readZ :: (MonadPlus m) => (Read a) => String -> m a
readZ :: forall (m :: * -> *) a. (MonadPlus m, Read a) => String -> m a
readZ = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall a. Read a => String -> Maybe a
S.readMay
assertZ :: (MonadPlus m) => Bool -> m ()
assertZ :: forall (m :: * -> *). MonadPlus m => Bool -> m ()
assertZ Bool
p = if Bool
p then forall (m :: * -> *) a. Monad m => a -> m a
return () else forall (m :: * -> *) a. MonadPlus m => m a
mzero
justZ :: (MonadPlus m) => Maybe a -> m a
justZ :: forall (m :: * -> *) a. MonadPlus m => Maybe a -> m a
justZ = forall b a. b -> (a -> b) -> Maybe a -> b
maybe forall (m :: * -> *) a. MonadPlus m => m a
mzero forall (m :: * -> *) a. Monad m => a -> m a
return
rightZ :: (MonadPlus m) => Either e a -> m a
rightZ :: forall (m :: * -> *) e a. MonadPlus m => Either e a -> m a
rightZ = forall a c b. (a -> c) -> (b -> c) -> Either a b -> c
either (forall a b. a -> b -> a
const forall (m :: * -> *) a. MonadPlus m => m a
mzero) forall (m :: * -> *) a. Monad m => a -> m a
return