workflow-types-0.0.1: Automate keyboard\/mouse\/clipboard\/application interaction.

Safe HaskellSafe
LanguageHaskell2010

Workflow.Reexports

Description

 

Synopsis

Documentation

class Monad m => MonadThrow m #

A class for monads in which exceptions may be thrown.

Instances should obey the following law:

throwM e >> x = throwM e

In other words, throwing an exception short-circuits the rest of the monadic computation.

Minimal complete definition

throwM

Instances

MonadThrow [] 

Methods

throwM :: Exception e => e -> [a] #

MonadThrow Maybe 

Methods

throwM :: Exception e => e -> Maybe a #

MonadThrow IO 

Methods

throwM :: Exception e => e -> IO a #

MonadThrow Q 

Methods

throwM :: Exception e => e -> Q a #

MonadThrow STM 

Methods

throwM :: Exception e => e -> STM a #

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

Methods

throwM :: Exception e => e -> Either e a #

MonadThrow m => MonadThrow (ListT m) 

Methods

throwM :: Exception e => e -> ListT m a #

MonadThrow m => MonadThrow (MaybeT m)

Throws exceptions into the base monad.

Methods

throwM :: Exception e => e -> MaybeT m a #

MonadThrow m => MonadThrow (IdentityT * m) 

Methods

throwM :: Exception e => e -> IdentityT * m a #

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

Methods

throwM :: Exception e => e -> FreeT f m a #

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

Throws exceptions into the base monad.

Methods

throwM :: Exception e => e -> ErrorT e m a #

MonadThrow m => MonadThrow (ExceptT e m)

Throws exceptions into the base monad.

Methods

throwM :: Exception e => e -> ExceptT e m a #

MonadThrow m => MonadThrow (StateT s m) 

Methods

throwM :: Exception e => e -> StateT s m a #

MonadThrow m => MonadThrow (StateT s m) 

Methods

throwM :: Exception e => e -> StateT s m a #

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

Methods

throwM :: Exception e => e -> WriterT w m a #

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

Methods

throwM :: Exception e => e -> WriterT w m a #

MonadThrow m => MonadThrow (ContT * r m) 

Methods

throwM :: Exception e => e -> ContT * r m a #

MonadThrow m => MonadThrow (ReaderT * r m) 

Methods

throwM :: Exception e => e -> ReaderT * r m a #

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

Methods

throwM :: Exception e => e -> RWST r w s m a #

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

Methods

throwM :: Exception e => e -> RWST r w s m a #

class Monad m => MonadFree f m | m -> f #

Monads provide substitution (fmap) and renormalization (join):

m >>= f = join (fmap f m)

A free Monad is one that does no work during the normalization step beyond simply grafting the two monadic values together.

[] is not a free Monad (in this sense) because join [[a]] smashes the lists flat.

On the other hand, consider:

data Tree a = Bin (Tree a) (Tree a) | Tip a
instance Monad Tree where
  return = Tip
  Tip a >>= f = f a
  Bin l r >>= f = Bin (l >>= f) (r >>= f)

This Monad is the free Monad of Pair:

data Pair a = Pair a a

And we could make an instance of MonadFree for it directly:

instance MonadFree Pair Tree where
   wrap (Pair l r) = Bin l r

Or we could choose to program with Free Pair instead of Tree and thereby avoid having to define our own Monad instance.

Moreover, Control.Monad.Free.Church provides a MonadFree instance that can improve the asymptotic complexity of code that constructs free monads by effectively reassociating the use of (>>=). You may also want to take a look at the kan-extensions package (http://hackage.haskell.org/package/kan-extensions).

See Free for a more formal definition of the free Monad for a Functor.

Instances

(Functor f, MonadFree f m) => MonadFree f (MaybeT m) 

Methods

wrap :: f (MaybeT m a) -> MaybeT m a #

(Functor f, MonadFree f m) => MonadFree f (ListT m) 

Methods

wrap :: f (ListT m a) -> ListT m a #

Functor f => MonadFree f (Free f) 

Methods

wrap :: f (Free f a) -> Free f a #

(Functor f, Monad m) => MonadFree f (FreeT f m) 

Methods

wrap :: f (FreeT f m a) -> FreeT f m a #

(Functor f, MonadFree f m, Monoid w) => MonadFree f (WriterT w m) 

Methods

wrap :: f (WriterT w m a) -> WriterT w m a #

(Functor f, MonadFree f m, Monoid w) => MonadFree f (WriterT w m) 

Methods

wrap :: f (WriterT w m a) -> WriterT w m a #

(Functor f, MonadFree f m) => MonadFree f (StateT s m) 

Methods

wrap :: f (StateT s m a) -> StateT s m a #

(Functor f, MonadFree f m) => MonadFree f (StateT s m) 

Methods

wrap :: f (StateT s m a) -> StateT s m a #

(Functor f, MonadFree f m) => MonadFree f (IdentityT * m) 

Methods

wrap :: f (IdentityT * m a) -> IdentityT * m a #

(Functor f, MonadFree f m) => MonadFree f (ExceptT e m) 

Methods

wrap :: f (ExceptT e m a) -> ExceptT e m a #

(Functor f, MonadFree f m, Error e) => MonadFree f (ErrorT e m) 

Methods

wrap :: f (ErrorT e m a) -> ErrorT e m a #

(Functor f, MonadFree f m) => MonadFree f (ReaderT * e m) 

Methods

wrap :: f (ReaderT * e m a) -> ReaderT * e m a #

(Functor f, MonadFree f m) => MonadFree f (ContT * r m) 

Methods

wrap :: f (ContT * r m a) -> ContT * r m a #

(Functor f, MonadFree f m, Monoid w) => MonadFree f (RWST r w s m) 

Methods

wrap :: f (RWST r w s m a) -> RWST r w s m a #

(Functor f, MonadFree f m, Monoid w) => MonadFree f (RWST r w s m) 

Methods

wrap :: f (RWST r w s m a) -> RWST r w s m a #