Skip to content

HORIZON HASKELL Docs lts/ghc-10.0.x77a86622026-10-31Search packagesCtrl K

Theme: |

GHC 10.0.0.20260917 · lts/ghc-10.0.x · 77a8662 · 2026-10-31

Moduleerrors-2.3.0Haskell98

Control.Error.Util

This module exports miscellaneous error-handling functions.

Contents

Conversion
Bool
Maybe
MaybeT
Either
ExceptT
Error Reporting
Exceptions

Synopsis

Packageerrors-2.3.0
Exports32
LanguageHaskell98
LicenceBSD-3-Clause
SourceUtil.hs

Conversion

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

valuehush :: Either a b -> Maybe b

Suppress the Left value of an Either

valuehushT :: Monad m => ExceptT a m b -> MaybeT m b

Suppress the Left value of an ExceptT

valuenote :: a -> Maybe b -> Either a b

Tag the Nothing value of a Maybe

valuenoteT :: Monad m => a -> MaybeT m b -> ExceptT a m b

Tag the Nothing value of a MaybeT

valuehoistMaybe :: Monad m => Maybe b -> MaybeT m b

Lift a Maybe to the MaybeT monad

valuehoistEither :: Monad m => Either e a -> ExceptT e m a

Upgrade an Either to an ExceptT

value(??) :: Applicative m => Maybe a -> e -> ExceptT e m a

Convert a Maybe value into the ExceptT monad

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

Convert an applicative Maybe value into the ExceptT monad

valuefailWith :: Applicative m => e -> Maybe a -> ExceptT e m a

Convert a Maybe value into the ExceptT monad

Named version of (??) with arguments flipped

valuefailWithM :: Applicative m => e -> m (Maybe a) -> ExceptT e m a

Convert an applicative Maybe value into the ExceptT monad

Named version of (!?) with arguments flipped

Bool

valuebool :: a -> a -> Bool -> a

Case analysis for the Bool type.

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

Maybe

value(?:) :: Maybe a -> a -> a

An infix form of fromMaybe with arguments flipped.

MaybeT

valuemaybeT :: Monad m => m b -> (a -> m b) -> MaybeT m a -> m b

Case analysis for MaybeT

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

valuejust :: Monad m => a -> MaybeT m a

Analogous to Just and equivalent to return

valuenothing :: Monad m => MaybeT m a

Analogous to Nothing and equivalent to mzero

valueisJustT :: Monad m => MaybeT m a -> m Bool

Analogous to isJust, but for MaybeT

valueisNothingT :: Monad m => MaybeT m a -> m Bool

Analogous to isNothing, but for MaybeT

Either

valueisLeft :: Either a b -> Bool

Returns whether argument is a Left

valueisRight :: Either a b -> Bool

Returns whether argument is a Right

valuefmapR :: (a -> b) -> Either l a -> Either l b

fmap specialized to Either, given a name symmetric to fmapL

newtypenewtype AllE e r

Run multiple Either computations and succeed if all of them succeed

mappends all successes or failures

Constructors

AllE
- runAllE :: Either e r

Instances2Semigroup, Monoid

(Semigroup e, Semigroup r) => Semigroup (AllE e r)Defined in errors-2.3.0 · Control.Error.Util
(Monoid e, Monoid r) => Monoid (AllE e r)Defined in errors-2.3.0 · Control.Error.Util

newtypenewtype AnyE e r

Run multiple Either computations and succeed if any of them succeed

mappends all successes or failures

Constructors

AnyE
- runAnyE :: Either e r

Instances2Semigroup, Monoid

(Semigroup e, Semigroup r) => Semigroup (AnyE e r)Defined in errors-2.3.0 · Control.Error.Util
(Monoid e, Monoid r) => Monoid (AnyE e r)Defined in errors-2.3.0 · Control.Error.Util

ExceptT

valueisLeftT :: Monad m => ExceptT a m b -> m Bool

Analogous to isLeft, but for ExceptT

valueisRightT :: Monad m => ExceptT a m b -> m Bool

Analogous to isRight, but for ExceptT

valuefmapRT :: Monad m => (a -> b) -> ExceptT l m a -> ExceptT l m b

fmap specialized to ExceptT, given a name symmetric to fmapLT

valueexceptT :: Monad m => (a -> m c) -> (b -> m c) -> ExceptT a m b -> m c

Fold an ExceptT by providing one continuation for each constructor

valuebimapExceptT

:: Functor m
=> e -> f
-> a -> b
-> ExceptT e m a
-> ExceptT f m b

Transform the left and right value

Error Reporting

valueerr :: Text -> IO ()

Write a string to standard error

valueerrLn :: Text -> IO ()

Write a string with a newline to standard error

Exceptions

valuetryIO :: MonadIO m => IO a -> ExceptT IOException m a

Catch IOExceptions and convert them to the ExceptT monad

valuehandleExceptT

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

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

valuesyncIO :: MonadIO m => IO a -> ExceptT SomeException m a

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