Network.AWS.Machines.AWS

Documentation

type AWSProcessT m a b = AWSMachineT m (Is a) b

A process transducing a stream of AWS values.

type AWSSourceT m b = forall k. AWSMachineT m k b

A stream of AWS values.

type RequestMod a = a -> a

Modifies an AWSRequest after the smart constructor has created it.

type M m = (MonadBaseControl IO m, MonadAWS (AWST' Env (ResourceT m)))

The base monad constraints for an AWSMachineT.

withAWS :: (MonadCatch m, MonadIO m, M m) => Credentials -> Logger -> Region -> AWSProcessT m a b -> m [b]

Run an AWSProcessT.

withAWSEnv :: (MonadCatch m, MonadIO m, M m) => Env -> AWSProcessT m a b -> m [b]

Run an AWSProcessT with an Env that's already set up.

awsSource :: (AWSRequest a, Foldable f) => GetResponse f a c -> [RequestMod a] -> a -> AWSSourceT m c

pagedSource

Arguments

:: (Foldable f, AWSPager a)

=> GetResponse f a c

Accessor for the list of ∈ in the response.

-> [RequestMod a]

Request modifiers

-> a

The initial request.

-> AWSSourceT m c

A Source of each ∈ in each page.

Stream an AWSPager instance.

liftAWS :: MonadAWS m => forall a. AWS a -> m a

Lift a computation to the AWS monad.

liftIO :: MonadIO m => forall a. IO a -> m a

Lift a computation from the IO monad.

class Monad m => MonadIO m where

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Minimal complete definition

liftIO

Methods

liftIO :: IO a -> m a

Lift a computation from the IO monad.

Instances

MonadIO IO

Methods

liftIO :: IO a -> IO a

MonadIO m => MonadIO (ResourceT m)

Methods

liftIO :: IO a -> ResourceT m a

MonadIO m => MonadIO (MaybeT m)

Methods

liftIO :: IO a -> MaybeT m a

MonadIO m => MonadIO (CatchT m)

Methods

liftIO :: IO a -> CatchT m a

MonadIO m => MonadIO (IterT m)

Methods

liftIO :: IO a -> IterT m a

MonadIO m => MonadIO (ListT m)

Methods

liftIO :: IO a -> ListT m a

MonadIO m => MonadIO (AWST' r m)

Methods

liftIO :: IO a -> AWST' r m a

MonadIO m => MonadIO (IdentityT * m)

Methods

liftIO :: IO a -> IdentityT * m a

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

Methods

liftIO :: IO a -> WriterT w m a

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

Methods

liftIO :: IO a -> WriterT w m a

MonadIO m => MonadIO (StateT s m)

Methods

liftIO :: IO a -> StateT s m a

MonadIO m => MonadIO (StateT s m)

Methods

liftIO :: IO a -> StateT s m a

(Error e, MonadIO m) => MonadIO (ErrorT e m)

Methods

liftIO :: IO a -> ErrorT e m a

(Functor f, MonadIO m) => MonadIO (FreeT f m)

Methods

liftIO :: IO a -> FreeT f m a

MonadIO m => MonadIO (ExceptT e m)

Methods

liftIO :: IO a -> ExceptT e m a

MonadIO m => MonadIO (ReaderT * r m)

Methods

liftIO :: IO a -> ReaderT * r m a

MonadIO m => MonadIO (ConduitM i o m)

Methods

liftIO :: IO a -> ConduitM i o m a

MonadIO m => MonadIO (ContT * r m)

Methods

liftIO :: IO a -> ContT * r m a

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

Methods

liftIO :: IO a -> RWST r w s m a

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

Methods

liftIO :: IO a -> RWST r w s m a

MonadIO m => MonadIO (Pipe l i o u m)

Methods

liftIO :: IO a -> Pipe l i o u m a

class (Functor m, Applicative m, Monad m, MonadIO m, MonadCatch m) => MonadAWS m where

Monads in which AWS actions may be embedded.

Minimal complete definition

liftAWS

Methods

liftAWS :: AWS a -> m a

Lift a computation to the AWS monad.

Instances

MonadAWS AWS

Methods

liftAWS :: AWS a -> AWS a

MonadAWS m => MonadAWS (MaybeT m)

Methods

liftAWS :: AWS a -> MaybeT m a

MonadAWS m => MonadAWS (ListT m)

Methods

liftAWS :: AWS a -> ListT m a

MonadAWS m => MonadAWS (IdentityT * m)

Methods

liftAWS :: AWS a -> IdentityT * m a

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

Methods

liftAWS :: AWS a -> WriterT w m a

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

Methods

liftAWS :: AWS a -> WriterT w m a

MonadAWS m => MonadAWS (StateT s m)

Methods

liftAWS :: AWS a -> StateT s m a

MonadAWS m => MonadAWS (StateT s m)

Methods

liftAWS :: AWS a -> StateT s m a

MonadAWS m => MonadAWS (ExceptT e m)

Methods

liftAWS :: AWS a -> ExceptT e m a

MonadAWS m => MonadAWS (ReaderT * r m)

Methods

liftAWS :: AWS a -> ReaderT * r m a

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

Methods

liftAWS :: AWS a -> RWST r w s m a

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

Methods

liftAWS :: AWS a -> RWST r w s m a

class MonadBase b m => MonadBaseControl b m | m -> b

Minimal complete definition

liftBaseWith, restoreM

Instances

MonadBaseControl [] []

Associated Types

type StM ([] :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase [] [] -> [a]) -> [a]

restoreM :: StM [] a -> [a]

MonadBaseControl Maybe Maybe

Associated Types

type StM (Maybe :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase Maybe Maybe -> Maybe a) -> Maybe a

restoreM :: StM Maybe a -> Maybe a

MonadBaseControl IO IO

Associated Types

type StM (IO :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase IO IO -> IO a) -> IO a

restoreM :: StM IO a -> IO a

MonadBaseControl Identity Identity

Associated Types

type StM (Identity :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase Identity Identity -> Identity a) -> Identity a

restoreM :: StM Identity a -> Identity a

MonadBaseControl STM STM

Associated Types

type StM (STM :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase STM STM -> STM a) -> STM a

restoreM :: StM STM a -> STM a

MonadBaseControl b m => MonadBaseControl b (ResourceT m)

Associated Types

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

Methods

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

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

MonadBaseControl b m => MonadBaseControl b (MaybeT m)

Associated Types

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

Methods

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

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

MonadBaseControl b m => MonadBaseControl b (ListT m)

Associated Types

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

Methods

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

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

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m)

Associated Types

type StM (WriterT w m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (WriterT w m) b -> b a) -> WriterT w m a

restoreM :: StM (WriterT w m) a -> WriterT w m a

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (WriterT w m)

Associated Types

type StM (WriterT w m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (WriterT w m) b -> b a) -> WriterT w m a

restoreM :: StM (WriterT w m) a -> WriterT w m a

MonadBaseControl b m => MonadBaseControl b (StateT s m)

Associated Types

type StM (StateT s m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a

restoreM :: StM (StateT s m) a -> StateT s m a

MonadBaseControl b m => MonadBaseControl b (StateT s m)

Associated Types

type StM (StateT s m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (StateT s m) b -> b a) -> StateT s m a

restoreM :: StM (StateT s m) a -> StateT s m a

MonadBaseControl b m => MonadBaseControl b (IdentityT * m)

Associated Types

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

Methods

liftBaseWith :: (RunInBase (IdentityT * m) b -> b a) -> IdentityT * m a

restoreM :: StM (IdentityT * m) a -> IdentityT * m a

MonadBaseControl b m => MonadBaseControl b (ExceptT e m)

Associated Types

type StM (ExceptT e m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (ExceptT e m) b -> b a) -> ExceptT e m a

restoreM :: StM (ExceptT e m) a -> ExceptT e m a

(Error e, MonadBaseControl b m) => MonadBaseControl b (ErrorT e m)

Associated Types

type StM (ErrorT e m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (ErrorT e m) b -> b a) -> ErrorT e m a

restoreM :: StM (ErrorT e m) a -> ErrorT e m a

MonadBaseControl b m => MonadBaseControl b (AWST' r m)

Associated Types

type StM (AWST' r m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (AWST' r m) b -> b a) -> AWST' r m a

restoreM :: StM (AWST' r m) a -> AWST' r m a

MonadBaseControl b m => MonadBaseControl b (ReaderT * r m)

Associated Types

type StM (ReaderT * r m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (ReaderT * r m) b -> b a) -> ReaderT * r m a

restoreM :: StM (ReaderT * r m) a -> ReaderT * r m a

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m)

Associated Types

type StM (RWST r w s m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (RWST r w s m) b -> b a) -> RWST r w s m a

restoreM :: StM (RWST r w s m) a -> RWST r w s m a

(Monoid w, MonadBaseControl b m) => MonadBaseControl b (RWST r w s m)

Associated Types

type StM (RWST r w s m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (RWST r w s m) b -> b a) -> RWST r w s m a

restoreM :: StM (RWST r w s m) a -> RWST r w s m a

MonadBaseControl ((->) r) ((->) r)

Associated Types

type StM ((->) r :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase ((->) r) ((->) r) -> r -> a) -> r -> a

restoreM :: StM ((->) r) a -> r -> a

MonadBaseControl (Either e) (Either e)

Associated Types

type StM (Either e :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (Either e) (Either e) -> Either e a) -> Either e a

restoreM :: StM (Either e) a -> Either e a

MonadBaseControl (ST s) (ST s)

Associated Types

type StM (ST s :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (ST s) (ST s) -> ST s a) -> ST s a

restoreM :: StM (ST s) a -> ST s a

MonadBaseControl (ST s) (ST s)

Associated Types

type StM (ST s :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (ST s) (ST s) -> ST s a) -> ST s a

restoreM :: StM (ST s) a -> ST s a

data AWST' r m a :: * -> (* -> *) -> * -> *

Instances

MonadAWS AWS

Methods

liftAWS :: AWS a -> AWS a

MonadState s m => MonadState s (AWST' r m)

Methods

get :: AWST' r m s

put :: s -> AWST' r m ()

state :: (s -> (a, s)) -> AWST' r m a

Monad m => MonadReader r (AWST' r m)

Methods

ask :: AWST' r m r

local :: (r -> r) -> AWST' r m a -> AWST' r m a

reader :: (r -> a) -> AWST' r m a

MonadBaseControl b m => MonadBaseControl b (AWST' r m)

Associated Types

type StM (AWST' r m :: * -> *) a :: *

Methods

liftBaseWith :: (RunInBase (AWST' r m) b -> b a) -> AWST' r m a

restoreM :: StM (AWST' r m) a -> AWST' r m a

MonadError e m => MonadError e (AWST' r m)

Methods

throwError :: e -> AWST' r m a

catchError :: AWST' r m a -> (e -> AWST' r m a) -> AWST' r m a

MonadWriter w m => MonadWriter w (AWST' r m)

Methods

writer :: (a, w) -> AWST' r m a

tell :: w -> AWST' r m ()

listen :: AWST' r m a -> AWST' r m (a, w)

pass :: AWST' r m (a, w -> w) -> AWST' r m a

MonadBase b m => MonadBase b (AWST' r m)

Methods

liftBase :: b α -> AWST' r m α

MFunctor (AWST' r)

Methods

hoist :: Monad m => (forall a. m a -> n a) -> AWST' r m b -> AWST' r n b

MonadTrans (AWST' r)

Methods

lift :: Monad m => m a -> AWST' r m a

MonadTransControl (AWST' r)

Associated Types

type StT (AWST' r :: (* -> *) -> * -> *) a :: *

Methods

liftWith :: Monad m => (Run (AWST' r) -> m a) -> AWST' r m a

restoreT :: Monad m => m (StT (AWST' r) a) -> AWST' r m a

Monad m => Monad (AWST' r m)

Methods

(>>=) :: AWST' r m a -> (a -> AWST' r m b) -> AWST' r m b

(>>) :: AWST' r m a -> AWST' r m b -> AWST' r m b

return :: a -> AWST' r m a

fail :: String -> AWST' r m a

Functor m => Functor (AWST' r m)

Methods

fmap :: (a -> b) -> AWST' r m a -> AWST' r m b

(<$) :: a -> AWST' r m b -> AWST' r m a

Applicative m => Applicative (AWST' r m)

Methods

pure :: a -> AWST' r m a

(<*>) :: AWST' r m (a -> b) -> AWST' r m a -> AWST' r m b

(*>) :: AWST' r m a -> AWST' r m b -> AWST' r m b

(<*) :: AWST' r m a -> AWST' r m b -> AWST' r m a

Alternative m => Alternative (AWST' r m)

Methods

empty :: AWST' r m a

(<|>) :: AWST' r m a -> AWST' r m a -> AWST' r m a

some :: AWST' r m a -> AWST' r m [a]

many :: AWST' r m a -> AWST' r m [a]

MonadPlus m => MonadPlus (AWST' r m)

Methods

mzero :: AWST' r m a

mplus :: AWST' r m a -> AWST' r m a -> AWST' r m a

MonadIO m => MonadIO (AWST' r m)

Methods

liftIO :: IO a -> AWST' r m a

MonadActive m => MonadActive (AWST' r m)

Methods

monadActive :: AWST' r m Bool

MonadThrow m => MonadThrow (AWST' r m)

Methods

throwM :: Exception e => e -> AWST' r m a

MonadCatch m => MonadCatch (AWST' r m)

Methods

catch :: Exception e => AWST' r m a -> (e -> AWST' r m a) -> AWST' r m a

MonadMask m => MonadMask (AWST' r m)

Methods

mask :: ((forall a. AWST' r m a -> AWST' r m a) -> AWST' r m b) -> AWST' r m b

uninterruptibleMask :: ((forall a. AWST' r m a -> AWST' r m a) -> AWST' r m b) -> AWST' r m b

MonadResource m => MonadResource (AWST' r m)

Methods

liftResourceT :: ResourceT IO a -> AWST' r m a

type StT (AWST' r) a

type StT (AWST' r) a = StT (ReaderT * r) a

type StM (AWST' r m) a

type StM (AWST' r m) a = ComposeSt (AWST' r) m a

data Env :: *

The environment containing the parameters required to make AWS requests.

Instances

MonadAWS AWS

Methods

liftAWS :: AWS a -> AWS a

HasEnv Env

Methods

environment :: Lens' Env Env

envRegion :: Lens' Env Region

envLogger :: Lens' Env Logger

envRetryCheck :: Lens' Env (Int -> HttpException -> Bool)

envOverride :: Lens' Env (Dual (Endo Service))

envManager :: Lens' Env Manager

envAuth :: Lens' Env Auth

envEC2 :: Getter Env (IORef (Maybe Bool))

ToLog Env

Methods

build :: Env -> Builder

data ResourceT m a :: (* -> *) -> * -> *

The Resource transformer. This transformer keeps track of all registered actions, and calls them upon exit (via runResourceT). Actions may be registered via register, or resources may be allocated atomically via allocate. allocate corresponds closely to bracket.

Releasing may be performed before exit via the release function. This is a highly recommended optimization, as it will ensure that scarce resources are freed early. Note that calling release will deregister the action, so that a release action will only ever be called once.

Since 0.3.0

Instances

MonadAWS AWS

Methods

liftAWS :: AWS a -> AWS a

MFunctor ResourceT

Since 0.4.7

Methods

hoist :: Monad m => (forall a. m a -> n a) -> ResourceT m b -> ResourceT n b

MMonad ResourceT

Since 0.4.7

Methods

embed :: Monad n => (forall a. m a -> ResourceT n a) -> ResourceT m b -> ResourceT n b

MonadTrans ResourceT

Methods

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

MonadTransControl ResourceT

Associated Types

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

Methods

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

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

MonadRWS r w s m => MonadRWS r w s (ResourceT m)

MonadState s m => MonadState s (ResourceT m)

Methods

get :: ResourceT m s

put :: s -> ResourceT m ()

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

MonadReader r m => MonadReader r (ResourceT m)

Methods

ask :: ResourceT m r

local :: (r -> r) -> ResourceT m a -> ResourceT m a

reader :: (r -> a) -> ResourceT m a

MonadBaseControl b m => MonadBaseControl b (ResourceT m)

Associated Types

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

Methods

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

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

MonadError e m => MonadError e (ResourceT m)

Methods

throwError :: e -> ResourceT m a

catchError :: ResourceT m a -> (e -> ResourceT m a) -> ResourceT m a

MonadWriter w m => MonadWriter w (ResourceT m)

Methods

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

tell :: w -> ResourceT m ()

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

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

MonadBase b m => MonadBase b (ResourceT m)

Methods

liftBase :: b α -> ResourceT m α

Monad m => Monad (ResourceT m)

Methods

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

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

return :: a -> ResourceT m a

fail :: String -> ResourceT m a

Functor m => Functor (ResourceT m)

Methods

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

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

MonadFix m => MonadFix (ResourceT m)

Since: 1.1.8

Methods

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

Applicative m => Applicative (ResourceT m)

Methods

pure :: a -> ResourceT m a

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

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

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

Alternative m => Alternative (ResourceT m)

Since 1.1.5

Methods

empty :: ResourceT m a

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

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

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

MonadPlus m => MonadPlus (ResourceT m)

Since 1.1.5

Methods

mzero :: ResourceT m a

mplus :: ResourceT m a -> ResourceT m a -> ResourceT m a

MonadIO m => MonadIO (ResourceT m)

Methods

liftIO :: IO a -> ResourceT m a

MonadThrow m => MonadThrow (ResourceT m)

Methods

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

MonadCatch m => MonadCatch (ResourceT m)

Methods

catch :: Exception e => ResourceT m a -> (e -> ResourceT m a) -> ResourceT m a

MonadMask m => MonadMask (ResourceT m)

Methods

mask :: ((forall a. ResourceT m a -> ResourceT m a) -> ResourceT m b) -> ResourceT m b

uninterruptibleMask :: ((forall a. ResourceT m a -> ResourceT m a) -> ResourceT m b) -> ResourceT m b

(MonadThrow m, MonadBase IO m, MonadIO m, Applicative m) => MonadResource (ResourceT m)

Methods

liftResourceT :: ResourceT IO a -> ResourceT m a

MonadCont m => MonadCont (ResourceT m)

Methods

callCC :: ((a -> ResourceT m b) -> ResourceT m a) -> ResourceT m a

type StT ResourceT a

type StT ResourceT a = a

type StM (ResourceT m) a

type StM (ResourceT m) a = StM m a

class MonadThrow m => MonadCatch m

A class for monads which allow exceptions to be caught, in particular exceptions which were thrown by throwM.

Instances should obey the following law:

catch (throwM e) f = f e

Note that the ability to catch an exception does not guarantee that we can deal with all possible exit points from a computation. Some monads, such as continuation-based stacks, allow for more than just a success/failure strategy, and therefore catch cannot be used by those monads to properly implement a function such as finally. For more information, see MonadMask.

Minimal complete definition

catch

Instances

MonadCatch IO

Methods

catch :: Exception e => IO a -> (e -> IO a) -> IO a

MonadCatch STM

Methods

catch :: Exception e => STM a -> (e -> STM a) -> STM a

(~) * e SomeException => MonadCatch (Either e)

Since: 0.8.3

Methods

catch :: Exception e => Either e a -> (e -> Either e a) -> Either e a

MonadCatch m => MonadCatch (ResourceT m)

Methods

catch :: Exception e => ResourceT m a -> (e -> ResourceT m a) -> ResourceT m a

MonadCatch m => MonadCatch (MaybeT m)

Catches exceptions from the base monad.

Methods

catch :: Exception e => MaybeT m a -> (e -> MaybeT m a) -> MaybeT m a

Monad m => MonadCatch (CatchT m)

Methods

catch :: Exception e => CatchT m a -> (e -> CatchT m a) -> CatchT m a

MonadCatch m => MonadCatch (IterT m)

Methods

catch :: Exception e => IterT m a -> (e -> IterT m a) -> IterT m a

MonadCatch m => MonadCatch (ListT m)

Methods

catch :: Exception e => ListT m a -> (e -> ListT m a) -> ListT m a

MonadCatch m => MonadCatch (AWST' r m)

Methods

catch :: Exception e => AWST' r m a -> (e -> AWST' r m a) -> AWST' r m a

MonadCatch m => MonadCatch (IdentityT * m)

Methods

catch :: Exception e => IdentityT * m a -> (e -> IdentityT * m a) -> IdentityT * m a

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

Methods

catch :: Exception e => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a

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

Methods

catch :: Exception e => WriterT w m a -> (e -> WriterT w m a) -> WriterT w m a

MonadCatch m => MonadCatch (StateT s m)

Methods

catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a

MonadCatch m => MonadCatch (StateT s m)

Methods

catch :: Exception e => StateT s m a -> (e -> StateT s m a) -> StateT s m a

(Error e, MonadCatch m) => MonadCatch (ErrorT e m)

Catches exceptions from the base monad.

Methods

catch :: Exception e => ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a

(Functor f, MonadCatch m) => MonadCatch (FreeT f m)

Methods

catch :: Exception e => FreeT f m a -> (e -> FreeT f m a) -> FreeT f m a

MonadCatch m => MonadCatch (ExceptT e m)

Catches exceptions from the base monad.

Methods

catch :: Exception e => ExceptT e m a -> (e -> ExceptT e m a) -> ExceptT e m a

MonadCatch m => MonadCatch (ReaderT * r m)

Methods

catch :: Exception e => ReaderT * r m a -> (e -> ReaderT * r m a) -> ReaderT * r m a

MonadCatch m => MonadCatch (ConduitM i o m)

Methods

catch :: Exception e => ConduitM i o m a -> (e -> ConduitM i o m a) -> ConduitM i o m a

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

Methods

catch :: Exception e => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a

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

Methods

catch :: Exception e => RWST r w s m a -> (e -> RWST r w s m a) -> RWST r w s m a

MonadCatch m => MonadCatch (Pipe l i o u m)

Methods

catch :: Exception e => Pipe l i o u m a -> (e -> Pipe l i o u m a) -> Pipe l i o u m a