exceptions-0.8.3: Extensible optionally-pure exceptions

Copyright | (C) Edward Kmett 2013-2015, (c) Google Inc. 2012
License | BSD-style (see the file LICENSE)
Maintainer | Edward Kmett <ekmett@gmail.com>
Stability | experimental
Portability | non-portable
Safe Haskell | Trustworthy
Language | Haskell98

Control.Monad.Catch.Pure

Contents

- Transformer
- Typeclass

Description

This module supplies a 'pure' monad transformer that can be used for mock-testing code that throws exceptions, so long as those exceptions are always thrown with `throwM`.

Do not mix `CatchT` with `IO`. Choose one or the other for the bottom of your transformer stack!

Synopsis

- newtype CatchT m a = CatchT {
  - runCatchT :: m (Either SomeException a)
  }
- type Catch = CatchT Identity
- runCatch :: Catch a -> Either SomeException a
- mapCatchT :: (m (Either SomeException a) -> n (Either SomeException b)) -> CatchT m a -> CatchT n b
- module Control.Monad.Catch

# Transformer

The `transformers`-style monad transfomer

newtype CatchT m a #

Add `Exception` handling abilities to a `Monad`.

This should never be used in combination with `IO`. Think of `CatchT` as an alternative base monad for use with mocking code that solely throws exceptions via `throwM`.

Note: that `IO` monad has these abilities already, so stacking `CatchT` on top of it does not add any value and can possibly be confusing:

    >>> (error "Hello!" :: IO ()) `catch` (\(e :: ErrorCall) -> liftIO $ print e)
    Hello!

    >>> runCatchT $ (error "Hello!" :: CatchT IO ()) `catch` (\(e :: ErrorCall) -> liftIO $ print e)
    *** Exception: Hello!

    >>> runCatchT $ (throwM (ErrorCall "Hello!") :: CatchT IO ()) `catch` (\(e :: ErrorCall) -> liftIO $ print e)
    Hello!

Constructors

CatchT |
Fields runCatchT :: m (Either SomeException a)

Instances

MonadTrans CatchT # |
Methods lift :: Monad m => m a -> CatchT m a #
MonadRWS r w s m => MonadRWS r w s (CatchT m) # |
MonadReader e m => MonadReader e (CatchT m) # |
Methods ask :: CatchT m e # local :: (e -> e) -> CatchT m a -> CatchT m a # reader :: (e -> a) -> CatchT m a #
MonadState s m => MonadState s (CatchT m) # |
Methods get :: CatchT m s # put :: s -> CatchT m () # state :: (s -> (a, s)) -> CatchT m a #
MonadWriter w m => MonadWriter w (CatchT m) # |
Methods writer :: (a, w) -> CatchT m a # tell :: w -> CatchT m () # listen :: CatchT m a -> CatchT m (a, w) # pass :: CatchT m (a, w -> w) -> CatchT m a #
Monad m => Monad (CatchT m) # |
Methods (>>=) :: CatchT m a -> (a -> CatchT m b) -> CatchT m b # (>>) :: CatchT m a -> CatchT m b -> CatchT m b # return :: a -> CatchT m a # fail :: String -> CatchT m a #
Monad m => Functor (CatchT m) # |
Methods fmap :: (a -> b) -> CatchT m a -> CatchT m b # (<$) :: a -> CatchT m b -> CatchT m a #
MonadFix m => MonadFix (CatchT m) # |
Methods mfix :: (a -> CatchT m a) -> CatchT m a #
Monad m => Applicative (CatchT m) # |
Methods pure :: a -> CatchT m a # (<*>) :: CatchT m (a -> b) -> CatchT m a -> CatchT m b # (*>) :: CatchT m a -> CatchT m b -> CatchT m b # (<*) :: CatchT m a -> CatchT m b -> CatchT m a #
Foldable m => Foldable (CatchT m) # |
Methods fold :: Monoid m => CatchT m m -> m # foldMap :: Monoid m => (a -> m) -> CatchT m a -> m # foldr :: (a -> b -> b) -> b -> CatchT m a -> b # foldr' :: (a -> b -> b) -> b -> CatchT m a -> b # foldl :: (b -> a -> b) -> b -> CatchT m a -> b # foldl' :: (b -> a -> b) -> b -> CatchT m a -> b # foldr1 :: (a -> a -> a) -> CatchT m a -> a # foldl1 :: (a -> a -> a) -> CatchT m a -> a # toList :: CatchT m a -> [a] # null :: CatchT m a -> Bool # length :: CatchT m a -> Int # elem :: Eq a => a -> CatchT m a -> Bool # maximum :: Ord a => CatchT m a -> a # minimum :: Ord a => CatchT m a -> a # sum :: Num a => CatchT m a -> a # product :: Num a => CatchT m a -> a #
(Monad m, Traversable m) => Traversable (CatchT m) # |
Methods traverse :: Applicative f => (a -> f b) -> CatchT m a -> f (CatchT m b) # sequenceA :: Applicative f => CatchT m (f a) -> f (CatchT m a) # mapM :: Monad m => (a -> m b) -> CatchT m a -> m (CatchT m b) # sequence :: Monad m => CatchT m (m a) -> m (CatchT m a) #
MonadIO m => MonadIO (CatchT m) # |
Methods liftIO :: IO a -> CatchT m a #
Monad m => Alternative (CatchT m) # |
Methods empty :: CatchT m a # (<|>) :: CatchT m a -> CatchT m a -> CatchT m a # some :: CatchT m a -> CatchT m [a] # many :: CatchT m a -> CatchT m [a] #
Monad m => MonadPlus (CatchT m) # |
Methods mzero :: CatchT m a # mplus :: CatchT m a -> CatchT m a -> CatchT m a #
Monad m => MonadMask (CatchT m) # | Note: This instance is only valid if the underlying monad has a single exit point!
Methods mask :: ((forall a. CatchT m a -> CatchT m a) -> CatchT m b) -> CatchT m b # uninterruptibleMask :: ((forall a. CatchT m a -> CatchT m a) -> CatchT m b) -> CatchT m b #
Monad m => MonadCatch (CatchT m) # |
Methods catch :: Exception e => CatchT m a -> (e -> CatchT m a) -> CatchT m a #
Monad m => MonadThrow (CatchT m) # |
Methods throwM :: Exception e => e -> CatchT m a #

type Catch = CatchT Identity #

runCatch :: Catch a -> Either SomeException a #

mapCatchT :: (m (Either SomeException a) -> n (Either SomeException b)) -> CatchT m a -> CatchT n b #

Map the unwrapped computation using the given function.

    runCatchT (mapCatchT f m) = f (runCatchT m)

# Typeclass

The mtl style typeclass

module Control.Monad.Catch