Data.Fail

Documentation

data Fail a

Constructors

Err !Text

Ok !a

Instances

Functor Fail

Methods

fmap :: (a -> b) -> Fail a -> Fail b

(<$) :: a -> Fail b -> Fail a

Foldable Fail

Methods

fold :: Monoid m => Fail m -> m

foldMap :: Monoid m => (a -> m) -> Fail a -> m

foldr :: (a -> b -> b) -> b -> Fail a -> b

foldr' :: (a -> b -> b) -> b -> Fail a -> b

foldl :: (b -> a -> b) -> b -> Fail a -> b

foldl' :: (b -> a -> b) -> b -> Fail a -> b

foldr1 :: (a -> a -> a) -> Fail a -> a

foldl1 :: (a -> a -> a) -> Fail a -> a

toList :: Fail a -> [a]

null :: Fail a -> Bool

length :: Fail a -> Int

elem :: Eq a => a -> Fail a -> Bool

maximum :: Ord a => Fail a -> a

minimum :: Ord a => Fail a -> a

sum :: Num a => Fail a -> a

product :: Num a => Fail a -> a

Traversable Fail

Methods

traverse :: Applicative f => (a -> f b) -> Fail a -> f (Fail b)

sequenceA :: Applicative f => Fail (f a) -> f (Fail a)

mapM :: Monad m => (a -> m b) -> Fail a -> m (Fail b)

sequence :: Monad m => Fail (m a) -> m (Fail a)

MonadFailure Fail

Methods

catchFailure :: Fail a -> (String -> Fail a) -> Fail a

Eq a => Eq (Fail a)

Methods

(==) :: Fail a -> Fail a -> Bool

(/=) :: Fail a -> Fail a -> Bool

Ord a => Ord (Fail a)

Methods

compare :: Fail a -> Fail a -> Ordering

(<) :: Fail a -> Fail a -> Bool

(<=) :: Fail a -> Fail a -> Bool

(>) :: Fail a -> Fail a -> Bool

(>=) :: Fail a -> Fail a -> Bool

max :: Fail a -> Fail a -> Fail a

min :: Fail a -> Fail a -> Fail a

Show a => Show (Fail a)

Methods

showsPrec :: Int -> Fail a -> ShowS

show :: Fail a -> String

showList :: [Fail a] -> ShowS

pattern Fail :: forall a. String -> Fail a

isFail :: Fail a -> Bool

isOk :: Fail a -> Bool

newtype FailT m a

Constructors

FailT (m (Fail a))

Instances

Functor m => Functor (FailT m)

Methods

fmap :: (a -> b) -> FailT m a -> FailT m b

(<$) :: a -> FailT m b -> FailT m a

Monad m => MonadFailure (FailT m)

Methods

catchFailure :: FailT m a -> (String -> FailT m a) -> FailT m a

type StT FailT a

type StT FailT a = Fail a

type StM (FailT m) a

type StM (FailT m) a = ComposeSt FailT m a

runFailT :: FailT m a -> m (Fail a)

type FIO a = FailT IO a

failEitherStr :: Either String a -> Fail a

failEitherShow :: Show a => Either a b -> Fail b

failEitherText :: Either Text a -> Fail a

runExceptTFail :: Monad m => ExceptT String m a -> m (Fail a)

failInM :: Monad m => Fail a -> m a

failInM' :: Monad m => Fail a -> (String -> String) -> m a

failInM'' :: Monad m => String -> Fail a -> m a

failToEither :: Fail a -> Either String a

failMaybe :: String -> Maybe a -> Fail a

failToMaybe :: Fail a -> Maybe a

mapFail :: (String -> String) -> Fail a -> Fail a

failSwitch :: (String -> c) -> (a -> c) -> Fail a -> c

fromFail :: (String -> a) -> Fail a -> a

class MonadFail m => MonadFailure m where

Minimal complete definition

catchFailure

Methods

catchFailure :: m a -> (String -> m a) -> m a

Instances

MonadFailure Maybe

Methods

catchFailure :: Maybe a -> (String -> Maybe a) -> Maybe a

MonadFailure IO

Methods

catchFailure :: IO a -> (String -> IO a) -> IO a

MonadFailure Fail

Methods

catchFailure :: Fail a -> (String -> Fail a) -> Fail a

Monad m => MonadFailure (FailT m)

Methods

catchFailure :: FailT m a -> (String -> FailT m a) -> FailT m a

(MonadFail (ReaderT * r m), MonadFailure m) => MonadFailure (ReaderT * r m)

Methods

catchFailure :: ReaderT * r m a -> (String -> ReaderT * r m a) -> ReaderT * r m a

failForIOException :: IO a -> IO (Fail a)

catFails :: [Fail a] -> [a]

eitherToError :: MonadError e m => Either e a -> m a

errorToEither :: MonadError e m => m a -> m (Either e a)

liftError :: (MonadError e m, MonadError e m1) => (forall a. m a -> m1 a) -> m a -> m1 a

errorToDefault :: MonadError e m => a -> m a -> m a

errorToMaybe :: MonadError e m => m a -> m (Maybe a)

maybeToError :: MonadError e m => String -> Maybe a -> m a

runError :: forall a. (forall m. Monad m => m a) -> Either String a

runExceptTorFail :: (Monad m, Show e) => ExceptT e m a -> m a

maybeToFail :: Monad m => String -> Maybe a -> m a

eitherToFail :: Monad m => Either String a -> m a

fromFailString :: Fail a -> Maybe String

partitionFails :: [Fail a] -> ([a], [String])

safeFromOk :: HasCallStack => Fail a -> a

class Monad m => MonadFail m

When a value is bound in do-notation, the pattern on the left hand side of <- might not match. In this case, this class provides a function to recover.

A Monad without a MonadFail instance may only be used in conjunction with pattern that always match, such as newtypes, tuples, data types with only a single data constructor, and irrefutable patterns (~pat).

Instances of MonadFail should satisfy the following law: fail s should be a left zero for >>=,

fail s >>= f  =  fail s

If your Monad is also MonadPlus, a popular definition is

fail _ = mzero

Since: 4.9.0.0

Minimal complete definition

fail

Instances

MonadFail []

Methods

fail :: String -> [a]

MonadFail Maybe

Methods

fail :: String -> Maybe a

MonadFail IO

Methods

fail :: String -> IO a

MonadFail Q

Methods

fail :: String -> Q a

MonadFail IResult

Methods

fail :: String -> IResult a

MonadFail Result

Methods

fail :: String -> Result a

MonadFail Parser

Methods

fail :: String -> Parser a

MonadFail P

Methods

fail :: String -> P a

MonadFail ReadPrec

Methods

fail :: String -> ReadPrec a

MonadFail ReadP

Methods

fail :: String -> ReadP a

MonadFail StrictList

Methods

fail :: String -> StrictList a

MonadFail Option

Methods

fail :: String -> Option a

MonadFail Vector

Methods

fail :: String -> Vector a

MonadFail (Parser i)

Methods

fail :: String -> Parser i a

Monad m => MonadFail (ListT m)

Methods

fail :: String -> ListT m a

Monad m => MonadFail (MaybeT m)

Methods

fail :: String -> MaybeT m a

Monad m => MonadFail (OptionT m)

Methods

fail :: String -> OptionT m a

(Monoid w, MonadFail m) => MonadFail (WriterT w m)

Methods

fail :: String -> WriterT w m a

MonadFail m => MonadFail (StateT s m)

Methods

fail :: String -> StateT s m a

MonadFail m => MonadFail (ExceptT e m)

Methods

fail :: String -> ExceptT e m a

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

Methods

fail :: String -> ErrorT e m a

MonadFail m => MonadFail (IdentityT * m)

Methods

fail :: String -> IdentityT * m a

MonadFail m => MonadFail (StateT s m)

Methods

fail :: String -> StateT s m a

(Monoid w, MonadFail m) => MonadFail (WriterT w m)

Methods

fail :: String -> WriterT w m a

MonadFail m => MonadFail (ReaderT * r m)

Methods

fail :: String -> ReaderT * r m a

MonadFail m => MonadFail (ContT * r m)

Methods

fail :: String -> ContT * r m a

(Monoid w, MonadFail m) => MonadFail (RWST r w s m)

Methods

fail :: String -> RWST r w s m a

(Monoid w, MonadFail m) => MonadFail (RWST r w s m)

Methods

fail :: String -> RWST r w s m a

Orphan instances

Monad Fail

Methods

(>>=) :: Fail a -> (a -> Fail b) -> Fail b

(>>) :: Fail a -> Fail b -> Fail b

return :: a -> Fail a

fail :: String -> Fail a

MonadFix Fail

Methods

mfix :: (a -> Fail a) -> Fail a

MonadFail Fail

Methods

fail :: String -> Fail a

Applicative Fail

Methods

pure :: a -> Fail a

(<*>) :: Fail (a -> b) -> Fail a -> Fail b

(*>) :: Fail a -> Fail b -> Fail b

(<*) :: Fail a -> Fail b -> Fail a

Alternative Fail

Methods

empty :: Fail a

(<|>) :: Fail a -> Fail a -> Fail a

some :: Fail a -> Fail [a]

many :: Fail a -> Fail [a]

MonadPlus Fail

Methods

mzero :: Fail a

mplus :: Fail a -> Fail a -> Fail a

MonadTrans FailT

Methods

lift :: Monad m => m a -> FailT m a

MonadTransControl FailT

Associated Types

type StT (FailT :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run FailT -> m a) -> FailT m a

restoreT :: Monad m => m (StT FailT a) -> FailT m a

MonadError String Fail

Methods

throwError :: String -> Fail a

catchError :: Fail a -> (String -> Fail a) -> Fail a

MonadBase b m => MonadBase b (FailT m)

Methods

liftBase :: b α -> FailT m α

MonadBaseControl b m => MonadBaseControl b (FailT m)

Associated Types

type StM (FailT m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (FailT m) b -> b a) -> FailT m a

restoreM :: StM (FailT m) a -> FailT m a

Monad m => MonadError String (FailT m)

Methods

throwError :: String -> FailT m a

catchError :: FailT m a -> (String -> FailT m a) -> FailT m a

MonadState s m => MonadState s (FailT m)

Methods

get :: FailT m s

put :: s -> FailT m ()

state :: (s -> (a, s)) -> FailT m a

MonadWriter w m => MonadWriter w (FailT m)

Methods

writer :: (a, w) -> FailT m a

tell :: w -> FailT m ()

listen :: FailT m a -> FailT m (a, w)

pass :: FailT m (a, w -> w) -> FailT m a

Monad m => Monad (FailT m)

Methods

(>>=) :: FailT m a -> (a -> FailT m b) -> FailT m b

(>>) :: FailT m a -> FailT m b -> FailT m b

return :: a -> FailT m a

fail :: String -> FailT m a

MonadFix m => MonadFix (FailT m)

Methods

mfix :: (a -> FailT m a) -> FailT m a

Monad m => MonadFail (FailT m)

Methods

fail :: String -> FailT m a

(Functor m, Monad m) => Applicative (FailT m)

Methods

pure :: a -> FailT m a

(<*>) :: FailT m (a -> b) -> FailT m a -> FailT m b

(*>) :: FailT m a -> FailT m b -> FailT m b

(<*) :: FailT m a -> FailT m b -> FailT m a

Arbitrary a => Arbitrary (Fail a)

Methods

arbitrary :: Gen (Fail a)

shrink :: Fail a -> [Fail a]

Monad m => Alternative (FailT m)

Methods

empty :: FailT m a

(<|>) :: FailT m a -> FailT m a -> FailT m a

some :: FailT m a -> FailT m [a]

many :: FailT m a -> FailT m [a]

Monad m => MonadPlus (FailT m)

Methods

mzero :: FailT m a

mplus :: FailT m a -> FailT m a -> FailT m a

MonadIO m => MonadIO (FailT m)

Methods

liftIO :: IO a -> FailT m a

MonadThrow m => MonadThrow (FailT m)

Methods

throwM :: Exception e => e -> FailT m a

MonadResource m => MonadResource (FailT m)

Methods

liftResourceT :: ResourceT IO a -> FailT m a