Safe Haskell | Safe-Inferred |
---|---|
Language | Haskell98 |
Control.Error
Contents
Description
Import this module in your code to access the entire library's functionality:
import Control.Error
This module exports the entire library as well as useful exports from other standard error-handling libraries:
- Control.Error.Safe: Generalizes the
safe
library, includingEither
,EitherT
, andMonadPlus
variations on total functions - Control.Error.Script: Support for simple scripts that catch all errors
and transform them to
Text
- Control.Error.Util: Utility functions and conversions between common error-handling types
Control.Monad.Trans.Except
: TheExceptT
monad transformerControl.Monad.Trans.Maybe
: TheMaybeT
monad transformerData.Either
:Either
utility functions- Data.EitherR: throw and catch functions, and their corresponding "success" monads
Data.Maybe
:Maybe
utility functionsSafe
: Total versions of partial Prelude functions
This module does not re-export partial functions from other libraries.
Synopsis
- module Control.Error.Safe
- module Control.Error.Script
- module Control.Error.Util
- newtype ExceptT e (m :: Type -> Type) a = ExceptT (m (Either e a))
- runExceptT :: ExceptT e m a -> m (Either e a)
- throwE :: forall (m :: Type -> Type) e a. Monad m => e -> ExceptT e m a
- catchE :: forall (m :: Type -> Type) e a e'. Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a
- mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b
- withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a
- newtype MaybeT (m :: Type -> Type) a = MaybeT {
- runMaybeT :: m (Maybe a)
- mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b
- liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b
- liftCatch :: Catch e m (Maybe a) -> Catch e (MaybeT m) a
- liftListen :: Monad m => Listen w m (Maybe a) -> Listen w (MaybeT m) a
- liftPass :: Monad m => Pass w m (Maybe a) -> Pass w (MaybeT m) a
- either :: (a -> c) -> (b -> c) -> Either a b -> c
- lefts :: [Either a b] -> [a]
- rights :: [Either a b] -> [b]
- partitionEithers :: [Either a b] -> ([a], [b])
- module Data.EitherR
- maybe :: b -> (a -> b) -> Maybe a -> b
- isJust :: Maybe a -> Bool
- isNothing :: Maybe a -> Bool
- fromMaybe :: a -> Maybe a -> a
- listToMaybe :: [a] -> Maybe a
- maybeToList :: Maybe a -> [a]
- catMaybes :: [Maybe a] -> [a]
- mapMaybe :: (a -> Maybe b) -> [a] -> [b]
- tailDef :: [a] -> [a] -> [a]
- tailMay :: [a] -> Maybe [a]
- tailSafe :: [a] -> [a]
- initDef :: [a] -> [a] -> [a]
- initMay :: [a] -> Maybe [a]
- initSafe :: [a] -> [a]
- headDef :: a -> [a] -> a
- headMay :: [a] -> Maybe a
- lastDef :: a -> [a] -> a
- lastMay :: [a] -> Maybe a
- minimumDef :: Ord a => a -> [a] -> a
- minimumMay :: Ord a => [a] -> Maybe a
- maximumDef :: Ord a => a -> [a] -> a
- maximumMay :: Ord a => [a] -> Maybe a
- foldr1Def :: a -> (a -> a -> a) -> [a] -> a
- foldr1May :: (a -> a -> a) -> [a] -> Maybe a
- foldl1Def' :: a -> (a -> a -> a) -> [a] -> a
- foldl1May' :: (a -> a -> a) -> [a] -> Maybe a
- fromJustDef :: a -> Maybe a -> a
- atDef :: a -> [a] -> Int -> a
- atMay :: [a] -> Int -> Maybe a
- readDef :: Read a => a -> String -> a
- readMay :: Read a => String -> Maybe a
- lookupJustDef :: Eq a => b -> a -> [(a, b)] -> b
- findJustDef :: a -> (a -> Bool) -> [a] -> a
Re-exports
module Control.Error.Safe
module Control.Error.Script
module Control.Error.Util
newtype ExceptT e (m :: Type -> Type) a #
Constructors
ExceptT (m (Either e a)) |
Instances
MonadTrans (ExceptT e) | |
Defined in Control.Monad.Trans.Except | |
MonadFail m => MonadFail (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadFix m => MonadFix (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadIO m => MonadIO (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
MonadZip m => MonadZip (ExceptT e m) | |
Foldable f => Foldable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except Methods fold :: Monoid m => ExceptT e f m -> m foldMap :: Monoid m => (a -> m) -> ExceptT e f a -> m foldMap' :: Monoid m => (a -> m) -> ExceptT e f a -> m foldr :: (a -> b -> b) -> b -> ExceptT e f a -> b foldr' :: (a -> b -> b) -> b -> ExceptT e f a -> b foldl :: (b -> a -> b) -> b -> ExceptT e f a -> b foldl' :: (b -> a -> b) -> b -> ExceptT e f a -> b foldr1 :: (a -> a -> a) -> ExceptT e f a -> a foldl1 :: (a -> a -> a) -> ExceptT e f a -> a toList :: ExceptT e f a -> [a] length :: ExceptT e f a -> Int elem :: Eq a => a -> ExceptT e f a -> Bool maximum :: Ord a => ExceptT e f a -> a minimum :: Ord a => ExceptT e f a -> a | |
(Eq e, Eq1 m) => Eq1 (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
(Ord e, Ord1 m) => Ord1 (ExceptT e m) | |
Defined in Control.Monad.Trans.Except Methods liftCompare :: (a -> b -> Ordering) -> ExceptT e m a -> ExceptT e m b -> Ordering | |
(Read e, Read1 m) => Read1 (ExceptT e m) | |
Defined in Control.Monad.Trans.Except Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (ExceptT e m a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [ExceptT e m a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (ExceptT e m a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [ExceptT e m a] | |
(Show e, Show1 m) => Show1 (ExceptT e m) | |
Defined in Control.Monad.Trans.Except Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> ExceptT e m a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [ExceptT e m a] -> ShowS | |
Contravariant m => Contravariant (ExceptT e m) | |
Traversable f => Traversable (ExceptT e f) | |
Defined in Control.Monad.Trans.Except | |
(Functor m, Monad m, Monoid e) => Alternative (ExceptT e m) | |
(Functor m, Monad m) => Applicative (ExceptT e m) | |
Defined in Control.Monad.Trans.Except | |
Functor m => Functor (ExceptT e m) | |
Monad m => Monad (ExceptT e m) | |
(Monad m, Monoid e) => MonadPlus (ExceptT e m) | |
MonadCatch m => MonadCatch (ExceptT e m) | |
Defined in Control.Monad.Catch | |
MonadMask m => MonadMask (ExceptT e m) | |
Defined in Control.Monad.Catch Methods mask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b uninterruptibleMask :: ((forall a. ExceptT e m a -> ExceptT e m a) -> ExceptT e m b) -> ExceptT e m b generalBracket :: ExceptT e m a -> (a -> ExitCase b -> ExceptT e m c) -> (a -> ExceptT e m b) -> ExceptT e m (b, c) | |
MonadThrow m => MonadThrow (ExceptT e m) | |
Defined in Control.Monad.Catch | |
(Read e, Read1 m, Read a) => Read (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except | |
(Show e, Show1 m, Show a) => Show (ExceptT e m a) | |
(Eq e, Eq1 m, Eq a) => Eq (ExceptT e m a) | |
(Ord e, Ord1 m, Ord a) => Ord (ExceptT e m a) | |
Defined in Control.Monad.Trans.Except |
runExceptT :: ExceptT e m a -> m (Either e a) #
catchE :: forall (m :: Type -> Type) e a e'. Monad m => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a #
mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b #
withExceptT :: forall (m :: Type -> Type) e e' a. Functor m => (e -> e') -> ExceptT e m a -> ExceptT e' m a #
newtype MaybeT (m :: Type -> Type) a #
Instances
MonadTrans MaybeT | |
Defined in Control.Monad.Trans.Maybe | |
Monad m => MonadFail (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
MonadFix m => MonadFix (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
MonadIO m => MonadIO (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
MonadZip m => MonadZip (MaybeT m) | |
Foldable f => Foldable (MaybeT f) | |
Defined in Control.Monad.Trans.Maybe Methods fold :: Monoid m => MaybeT f m -> m foldMap :: Monoid m => (a -> m) -> MaybeT f a -> m foldMap' :: Monoid m => (a -> m) -> MaybeT f a -> m foldr :: (a -> b -> b) -> b -> MaybeT f a -> b foldr' :: (a -> b -> b) -> b -> MaybeT f a -> b foldl :: (b -> a -> b) -> b -> MaybeT f a -> b foldl' :: (b -> a -> b) -> b -> MaybeT f a -> b foldr1 :: (a -> a -> a) -> MaybeT f a -> a foldl1 :: (a -> a -> a) -> MaybeT f a -> a elem :: Eq a => a -> MaybeT f a -> Bool maximum :: Ord a => MaybeT f a -> a minimum :: Ord a => MaybeT f a -> a | |
Eq1 m => Eq1 (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe | |
Ord1 m => Ord1 (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe Methods liftCompare :: (a -> b -> Ordering) -> MaybeT m a -> MaybeT m b -> Ordering | |
Read1 m => Read1 (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe Methods liftReadsPrec :: (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (MaybeT m a) liftReadList :: (Int -> ReadS a) -> ReadS [a] -> ReadS [MaybeT m a] liftReadPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec (MaybeT m a) liftReadListPrec :: ReadPrec a -> ReadPrec [a] -> ReadPrec [MaybeT m a] | |
Show1 m => Show1 (MaybeT m) | |
Defined in Control.Monad.Trans.Maybe Methods liftShowsPrec :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> MaybeT m a -> ShowS liftShowList :: (Int -> a -> ShowS) -> ([a] -> ShowS) -> [MaybeT m a] -> ShowS | |
Contravariant m => Contravariant (MaybeT m) | |
Traversable f => Traversable (MaybeT f) | |
(Functor m, Monad m) => Alternative (MaybeT m) | |
(Functor m, Monad m) => Applicative (MaybeT m) | |
Functor m => Functor (MaybeT m) | |
Monad m => Monad (MaybeT m) | |
Monad m => MonadPlus (MaybeT m) | |
MonadCatch m => MonadCatch (MaybeT m) | |
Defined in Control.Monad.Catch | |
MonadMask m => MonadMask (MaybeT m) | |
Defined in Control.Monad.Catch | |
MonadThrow m => MonadThrow (MaybeT m) | |
Defined in Control.Monad.Catch | |
(Read1 m, Read a) => Read (MaybeT m a) | |
Defined in Control.Monad.Trans.Maybe | |
(Show1 m, Show a) => Show (MaybeT m a) | |
(Eq1 m, Eq a) => Eq (MaybeT m a) | |
(Ord1 m, Ord a) => Ord (MaybeT m a) | |
liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b #
liftListen :: Monad m => Listen w m (Maybe a) -> Listen w (MaybeT m) a #
partitionEithers :: [Either a b] -> ([a], [b]) #
module Data.EitherR
listToMaybe :: [a] -> Maybe a #
maybeToList :: Maybe a -> [a] #
minimumDef :: Ord a => a -> [a] -> a #
minimumMay :: Ord a => [a] -> Maybe a #
maximumDef :: Ord a => a -> [a] -> a #
maximumMay :: Ord a => [a] -> Maybe a #
foldl1Def' :: a -> (a -> a -> a) -> [a] -> a #
foldl1May' :: (a -> a -> a) -> [a] -> Maybe a #
fromJustDef :: a -> Maybe a -> a #
lookupJustDef :: Eq a => b -> a -> [(a, b)] -> b #
findJustDef :: a -> (a -> Bool) -> [a] -> a #