errors-2.3.0: Simplified error-handling

Safe Haskell | Safe-Inferred
Language | Haskell98

Control.Error.Util

Contents

- Conversion
- Bool
- Maybe
- MaybeT
- Either
- ExceptT
- Error Reporting
- Exceptions

Description

This module exports miscellaneous error-handling functions.

Synopsis

- hush :: Either a b -> Maybe b
- hushT :: forall (m :: Type -> Type) a b. Monad m => ExceptT a m b -> MaybeT m b
- note :: a -> Maybe b -> Either a b
- noteT :: forall (m :: Type -> Type) a b. Monad m => a -> MaybeT m b -> ExceptT a m b
- hoistMaybe :: forall (m :: Type -> Type) b. Monad m => Maybe b -> MaybeT m b
- hoistEither :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a
- (??) :: forall (m :: Type -> Type) a e. Applicative m => Maybe a -> e -> ExceptT e m a
- (!?) :: Applicative m => m (Maybe a) -> e -> ExceptT e m a
- failWith :: forall (m :: Type -> Type) e a. Applicative m => e -> Maybe a -> ExceptT e m a
- failWithM :: Applicative m => e -> m (Maybe a) -> ExceptT e m a
- bool :: a -> a -> Bool -> a
- (?:) :: Maybe a -> a -> a
- maybeT :: Monad m => m b -> (a -> m b) -> MaybeT m a -> m b
- just :: forall (m :: Type -> Type) a. Monad m => a -> MaybeT m a
- nothing :: forall (m :: Type -> Type) a. Monad m => MaybeT m a
- isJustT :: Monad m => MaybeT m a -> m Bool
- isNothingT :: Monad m => MaybeT m a -> m Bool
- isLeft :: Either a b -> Bool
- isRight :: Either a b -> Bool
- fmapR :: (a -> b) -> Either l a -> Either l b
- newtype AllE e r = AllE {
  - runAllE :: Either e r
  }
- newtype AnyE e r = AnyE {
  - runAnyE :: Either e r
  }
- isLeftT :: Monad m => ExceptT a m b -> m Bool
- isRightT :: Monad m => ExceptT a m b -> m Bool
- fmapRT :: forall (m :: Type -> Type) a b l. Monad m => (a -> b) -> ExceptT l m a -> ExceptT l m b
- exceptT :: Monad m => (a -> m c) -> (b -> m c) -> ExceptT a m b -> m c
- bimapExceptT :: forall (m :: Type -> Type) e f a b. Functor m => (e -> f) -> (a -> b) -> ExceptT e m a -> ExceptT f m b
- err :: Text -> IO ()
- errLn :: Text -> IO ()
- tryIO :: forall (m :: Type -> Type) a. MonadIO m => IO a -> ExceptT IOException m a
- handleExceptT :: (Exception e, Functor m, MonadCatch m) => (e -> x) -> m a -> ExceptT x m a
- syncIO :: forall (m :: Type -> Type) a. MonadIO m => IO a -> ExceptT SomeException m a

# Conversion

Use these functions to convert between `Maybe`, `Either`, `MaybeT`, and `ExceptT`.

hush :: Either a b -> Maybe b Source #

Suppress the `Left` value of an `Either`

hushT :: forall (m :: Type -> Type) a b. Monad m => ExceptT a m b -> MaybeT m b Source #

Suppress the `Left` value of an `ExceptT`

note :: a -> Maybe b -> Either a b Source #

Tag the `Nothing` value of a `Maybe`

noteT :: forall (m :: Type -> Type) a b. Monad m => a -> MaybeT m b -> ExceptT a m b Source #

Tag the `Nothing` value of a `MaybeT`

hoistMaybe :: forall (m :: Type -> Type) b. Monad m => Maybe b -> MaybeT m b Source #

Lift a `Maybe` to the `MaybeT` monad

hoistEither :: forall (m :: Type -> Type) e a. Monad m => Either e a -> ExceptT e m a Source #

Upgrade an `Either` to an `ExceptT`

(??) :: forall (m :: Type -> Type) a e. Applicative m => Maybe a -> e -> ExceptT e m a Source #

Convert a `Maybe` value into the `ExceptT` monad

(!?) :: Applicative m => m (Maybe a) -> e -> ExceptT e m a Source #

Convert an applicative `Maybe` value into the `ExceptT` monad

failWith :: forall (m :: Type -> Type) e a. Applicative m => e -> Maybe a -> ExceptT e m a Source #

Convert a `Maybe` value into the `ExceptT` monad

Named version of (`??`) with arguments flipped

failWithM :: Applicative m => e -> m (Maybe a) -> ExceptT e m a Source #

Convert an applicative `Maybe` value into the `ExceptT` monad

Named version of (`!?`) with arguments flipped

# Bool

bool :: a -> a -> Bool -> a Source #

Case analysis for the `Bool` type.

    bool a b c == if c then b else a

# Maybe

(?:) :: Maybe a -> a -> a infixr 0 Source #

An infix form of `fromMaybe` with arguments flipped.

# MaybeT

maybeT :: Monad m => m b -> (a -> m b) -> MaybeT m a -> m b Source #

Case analysis for `MaybeT`

Use the first argument if the `MaybeT` computation fails, otherwise apply the function to the successful result.

just :: forall (m :: Type -> Type) a. Monad m => a -> MaybeT m a Source #

Analogous to `Just` and equivalent to `return`

nothing :: forall (m :: Type -> Type) a. Monad m => MaybeT m a Source #

Analogous to `Nothing` and equivalent to `mzero`

isJustT :: Monad m => MaybeT m a -> m Bool Source #

Analogous to `isJust`, but for `MaybeT`

isNothingT :: Monad m => MaybeT m a -> m Bool Source #

Analogous to `isNothing`, but for `MaybeT`

# Either

isLeft :: Either a b -> Bool Source #

Returns whether argument is a `Left`

isRight :: Either a b -> Bool Source #

Returns whether argument is a `Right`

fmapR :: (a -> b) -> Either l a -> Either l b Source #

`fmap` specialized to `Either`, given a name symmetric to `fmapL`

newtype AllE e r Source #

Run multiple `Either` computations and succeed if all of them succeed

`mappend`s all successes or failures

Constructors

AllE |

Fields

- runAllE :: Either e r

#### Instances

Instances details

(Monoid e, Monoid r) => Monoid (AllE e r) Source # |
Instance details Defined in Control.Error.Util Methods mempty :: AllE e r Source # mappend :: AllE e r -> AllE e r -> AllE e r Source # mconcat :: [AllE e r] -> AllE e r Source #
(Semigroup e, Semigroup r) => Semigroup (AllE e r) Source # |
Instance details Defined in Control.Error.Util Methods (<>) :: AllE e r -> AllE e r -> AllE e r Source # sconcat :: NonEmpty (AllE e r) -> AllE e r Source # stimes :: Integral b => b -> AllE e r -> AllE e r Source #

newtype AnyE e r Source #

Run multiple `Either` computations and succeed if any of them succeed

`mappend`s all successes or failures

Constructors

AnyE |

Fields

- runAnyE :: Either e r

#### Instances

Instances details

(Monoid e, Monoid r) => Monoid (AnyE e r) Source # |
Instance details Defined in Control.Error.Util Methods mempty :: AnyE e r Source # mappend :: AnyE e r -> AnyE e r -> AnyE e r Source # mconcat :: [AnyE e r] -> AnyE e r Source #
(Semigroup e, Semigroup r) => Semigroup (AnyE e r) Source # |
Instance details Defined in Control.Error.Util Methods (<>) :: AnyE e r -> AnyE e r -> AnyE e r Source # sconcat :: NonEmpty (AnyE e r) -> AnyE e r Source # stimes :: Integral b => b -> AnyE e r -> AnyE e r Source #

# ExceptT

isLeftT :: Monad m => ExceptT a m b -> m Bool Source #

Analogous to `isLeft`, but for `ExceptT`

isRightT :: Monad m => ExceptT a m b -> m Bool Source #

Analogous to `isRight`, but for `ExceptT`

fmapRT :: forall (m :: Type -> Type) a b l. Monad m => (a -> b) -> ExceptT l m a -> ExceptT l m b Source #

`fmap` specialized to `ExceptT`, given a name symmetric to `fmapLT`

exceptT :: Monad m => (a -> m c) -> (b -> m c) -> ExceptT a m b -> m c Source #

Fold an `ExceptT` by providing one continuation for each constructor

bimapExceptT :: forall (m :: Type -> Type) e f a b. Functor m => (e -> f) -> (a -> b) -> ExceptT e m a -> ExceptT f m b Source #

Transform the left and right value

# Error Reporting

err :: Text -> IO () Source #

Write a string to standard error

errLn :: Text -> IO () Source #

Write a string with a newline to standard error

# Exceptions

tryIO :: forall (m :: Type -> Type) a. MonadIO m => IO a -> ExceptT IOException m a Source #

Catch `IOException`s and convert them to the `ExceptT` monad

handleExceptT :: (Exception e, Functor m, MonadCatch m) => (e -> x) -> m a -> ExceptT x m a Source #

Run a monad action which may throw an exception in the `ExceptT` monad

syncIO :: forall (m :: Type -> Type) a. MonadIO m => IO a -> ExceptT SomeException m a Source #

Catch all exceptions, except for asynchronous exceptions found in `base` and convert them to the `ExceptT` monad