-- Hoogle documentation, generated by Haddock -- See Hoogle, http://www.haskell.org/hoogle/ -- | Concrete functor and monad transformers -- -- A portable library of functor and monad transformers, inspired by the -- paper "Functional Programming with Overloading and Higher-Order -- Polymorphism", by Mark P Jones, in Advanced School of Functional -- Programming, 1995 -- (http://web.cecs.pdx.edu/~mpj/pubs/springschool.html). -- -- This package contains: -- --

the monad transformer class (in Control.Monad.Trans.Class) -- and IO monad class (in Control.Monad.IO.Class)
concrete functor and monad transformers, each with associated -- operations and functions to lift operations associated with other -- transformers.

-- -- The package can be used on its own in portable Haskell code, in which -- case operations need to be manually lifted through transformer stacks -- (see Control.Monad.Trans.Class for some examples). -- Alternatively, it can be used with the non-portable monad classes in -- the mtl or monads-tf packages, which automatically -- lift operations introduced by monad transformers through other -- transformers. @package transformers @version 0.5.0.2 -- | Class of monads based on IO. module Control.Monad.IO.Class -- | 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)

class (Monad m) => MonadIO m -- | Lift a computation from the IO monad. liftIO :: MonadIO m => IO a -> m a instance Control.Monad.IO.Class.MonadIO GHC.Types.IO -- | The class of monad transformers. -- -- A monad transformer makes a new monad out of an existing monad, such -- that computations of the old monad may be embedded in the new one. To -- construct a monad with a desired set of features, one typically starts -- with a base monad, such as Identity, [] or IO, -- and applies a sequence of monad transformers. module Control.Monad.Trans.Class -- | The class of monad transformers. Instances should satisfy the -- following laws, which state that lift is a monad -- transformation: -- --

```
lift . return = return
```

lift (m >>= f) = lift m >>=
--   (lift . f)

class MonadTrans t -- | Lift a computation from the argument monad to the constructed monad. lift :: (MonadTrans t, Monad m) => m a -> t m a -- | Continuation monads. -- -- Delimited continuation operators are taken from Kenichi Asai and Oleg -- Kiselyov's tutorial at CW 2011, "Introduction to programming with -- shift and reset" -- (http://okmij.org/ftp/continuations/#tutorial). module Control.Monad.Trans.Cont -- | Continuation monad. Cont r a is a CPS computation that -- produces an intermediate result of type a within a CPS -- computation whose final result type is r. -- -- The return function simply creates a continuation which -- passes the value on. -- -- The >>= operator adds the bound function into the -- continuation chain. type Cont r = ContT r Identity -- | Construct a continuation-passing computation from a function. (The -- inverse of runCont) cont :: ((a -> r) -> r) -> Cont r a -- | The result of running a CPS computation with a given final -- continuation. (The inverse of cont) runCont :: Cont r a -> (a -> r) -> r -- | The result of running a CPS computation with the identity as the final -- continuation. -- --

```
evalCont (return x) = x
```

evalCont :: Cont r r -> r -- | Apply a function to transform the result of a continuation-passing -- computation. -- --

runCont (mapCont f m) = f . runCont
--   m

mapCont :: (r -> r) -> Cont r a -> Cont r a -- | Apply a function to transform the continuation passed to a CPS -- computation. -- --

runCont (withCont f m) = runCont m .
--   f

withCont :: ((b -> r) -> (a -> r)) -> Cont r a -> Cont r b -- | reset m delimits the continuation of any shift -- inside m. -- --

```
reset (return m) = return m
```

reset :: Cont r r -> Cont r' r -- | shift f captures the continuation up to the nearest -- enclosing reset and passes it to f: -- --

reset (shift f >>= k) = reset (f
--   (evalCont . k))

shift :: ((a -> r) -> Cont r r) -> Cont r a -- | The continuation monad transformer. Can be used to add continuation -- handling to other monads. newtype ContT r m a ContT :: ((a -> m r) -> m r) -> ContT r m a [runContT] :: ContT r m a -> (a -> m r) -> m r -- | The result of running a CPS computation with return as the -- final continuation. -- --

```
evalContT (lift m) = m
```

evalContT :: (Monad m) => ContT r m r -> m r -- | Apply a function to transform the result of a continuation-passing -- computation. -- --

runContT (mapContT f m) = f . runContT
--   m

mapContT :: (m r -> m r) -> ContT r m a -> ContT r m a -- | Apply a function to transform the continuation passed to a CPS -- computation. -- --

runContT (withContT f m) = runContT m .
--   f

withContT :: ((b -> m r) -> (a -> m r)) -> ContT r m a -> ContT r m b -- | callCC (call-with-current-continuation) calls its argument -- function, passing it the current continuation. It provides an escape -- continuation mechanism for use with continuation monads. Escape -- continuations one allow to abort the current computation and return a -- value immediately. They achieve a similar effect to throwE and -- catchE within an ExceptT monad. The advantage of this -- function over calling return is that it makes the continuation -- explicit, allowing more flexibility and better control. -- -- The standard idiom used with callCC is to provide a -- lambda-expression to name the continuation. Then calling the named -- continuation anywhere within its scope will escape from the -- computation, even if it is many layers deep within nested -- computations. callCC :: ((a -> ContT r m b) -> ContT r m a) -> ContT r m a -- | resetT m delimits the continuation of any -- shiftT inside m. -- --

```
resetT (lift m) = lift m
```

resetT :: (Monad m) => ContT r m r -> ContT r' m r -- | shiftT f captures the continuation up to the nearest -- enclosing resetT and passes it to f: -- --

resetT (shiftT f >>= k) = resetT
--   (f (evalContT . k))

shiftT :: (Monad m) => ((a -> m r) -> ContT r m r) -> ContT r m a -- | liftLocal ask local yields a local function -- for ContT r m. liftLocal :: (Monad m) => m r' -> ((r' -> r') -> m r -> m r) -> (r' -> r') -> ContT r m a -> ContT r m a instance forall (k :: BOX) (r :: k) (m :: k -> *). GHC.Base.Functor (Control.Monad.Trans.Cont.ContT r m) instance forall (k :: BOX) (r :: k) (m :: k -> *). GHC.Base.Applicative (Control.Monad.Trans.Cont.ContT r m) instance forall (k :: BOX) (r :: k) (m :: k -> *). GHC.Base.Monad (Control.Monad.Trans.Cont.ContT r m) instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Cont.ContT r) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Cont.ContT r m) -- | Signatures for monad operations that require specialized lifting. Each -- signature has a uniformity property that the lifting should satisfy. module Control.Monad.Signatures -- | Signature of the callCC operation, introduced in -- Control.Monad.Trans.Cont. Any lifting function -- liftCallCC should satisfy -- --

lift (f k) = f' (lift . k) =>
--   lift (cf f) = liftCallCC cf f'

type CallCC m a b = ((a -> m b) -> m a) -> m a -- | Signature of the catchE operation, introduced in -- Control.Monad.Trans.Except. Any lifting function -- liftCatch should satisfy -- --

lift (cf m f) = liftCatch (lift . cf)
--   (lift f)

type Catch e m a = m a -> (e -> m a) -> m a -- | Signature of the listen operation, introduced in -- Control.Monad.Trans.Writer. Any lifting function -- liftListen should satisfy -- --

lift . liftListen = liftListen .
--   lift

type Listen w m a = m a -> m (a, w) -- | Signature of the pass operation, introduced in -- Control.Monad.Trans.Writer. Any lifting function -- liftPass should satisfy -- --

```
lift . liftPass = liftPass .
--   lift
```

type Pass w m a = m (a, w -> w) -> m a -- | Declaration of the ReaderT monad transformer, which adds a -- static environment to a given monad. -- -- If the computation is to modify the stored information, use -- Control.Monad.Trans.State instead. module Control.Monad.Trans.Reader -- | The parameterizable reader monad. -- -- Computations are functions of a shared environment. -- -- The return function ignores the environment, while -- >>= passes the inherited environment to both -- subcomputations. type Reader r = ReaderT r Identity -- | Constructor for computations in the reader monad (equivalent to -- asks). reader :: (Monad m) => (r -> a) -> ReaderT r m a -- | Runs a Reader and extracts the final value from it. (The -- inverse of reader.) runReader :: Reader r a -> r -> a -- | Transform the value returned by a Reader. -- --

runReader (mapReader f m) = f .
--   runReader m

mapReader :: (a -> b) -> Reader r a -> Reader r b -- | Execute a computation in a modified environment (a specialization of -- withReaderT). -- --

runReader (withReader f m) = runReader m
--   . f

withReader :: (r' -> r) -> Reader r a -> Reader r' a -- | The reader monad transformer, which adds a read-only environment to -- the given monad. -- -- The return function ignores the environment, while -- >>= passes the inherited environment to both -- subcomputations. newtype ReaderT r m a ReaderT :: (r -> m a) -> ReaderT r m a [runReaderT] :: ReaderT r m a -> r -> m a -- | Transform the computation inside a ReaderT. -- --

runReaderT (mapReaderT f m) = f .
--   runReaderT m

mapReaderT :: (m a -> n b) -> ReaderT r m a -> ReaderT r n b -- | Execute a computation in a modified environment (a more general -- version of local). -- --

runReaderT (withReaderT f m) =
--   runReaderT m . f

withReaderT :: (r' -> r) -> ReaderT r m a -> ReaderT r' m a -- | Fetch the value of the environment. ask :: (Monad m) => ReaderT r m r -- | Execute a computation in a modified environment (a specialization of -- withReaderT). -- --

runReaderT (local f m) = runReaderT m .
--   f

local :: (r -> r) -> ReaderT r m a -> ReaderT r m a -- | Retrieve a function of the current environment. -- --

```
asks f = liftM f ask
```

asks :: (Monad m) => (r -> a) -> ReaderT r m a -- | Lift a callCC operation to the new monad. liftCallCC :: CallCC m a b -> CallCC (ReaderT r m) a b -- | Lift a catchE operation to the new monad. liftCatch :: Catch e m a -> Catch e (ReaderT r m) a instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Reader.ReaderT r m) instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Monad.Trans.Reader.ReaderT r m) instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Monad.Trans.Reader.ReaderT r m) instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.Reader.ReaderT r m) instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.Reader.ReaderT r m) instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Reader.ReaderT r m) instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Reader.ReaderT r) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Reader.ReaderT r m) instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Control.Monad.Trans.Reader.ReaderT r m) -- | A monad transformer that combines ReaderT, WriterT -- and StateT. This version is lazy; for a strict version with -- the same interface, see Control.Monad.Trans.RWS.Strict. module Control.Monad.Trans.RWS.Lazy -- | A monad containing an environment of type r, output of type -- w and an updatable state of type s. type RWS r w s = RWST r w s Identity -- | Construct an RWS computation from a function. (The inverse of -- runRWS.) rws :: (r -> s -> (a, s, w)) -> RWS r w s a -- | Unwrap an RWS computation as a function. (The inverse of rws.) runRWS :: RWS r w s a -> r -> s -> (a, s, w) -- | Evaluate a computation with the given initial state and environment, -- returning the final value and output, discarding the final state. evalRWS :: RWS r w s a -> r -> s -> (a, w) -- | Evaluate a computation with the given initial state and environment, -- returning the final state and output, discarding the final value. execRWS :: RWS r w s a -> r -> s -> (s, w) -- | Map the return value, final state and output of a computation using -- the given function. -- --

runRWS (mapRWS f m) r s = f (runRWS m r
--   s)

mapRWS :: ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b -- | withRWS f m executes action m with an initial -- environment and state modified by applying f. -- --

runRWS (withRWS f m) r s = uncurry
--   (runRWS m) (f r s)

withRWS :: (r' -> s -> (r, s)) -> RWS r w s a -> RWS r' w s a -- | A monad transformer adding reading an environment of type r, -- collecting an output of type w and updating a state of type -- s to an inner monad m. newtype RWST r w s m a RWST :: (r -> s -> m (a, s, w)) -> RWST r w s m a [runRWST] :: RWST r w s m a -> r -> s -> m (a, s, w) -- | Evaluate a computation with the given initial state and environment, -- returning the final value and output, discarding the final state. evalRWST :: (Monad m) => RWST r w s m a -> r -> s -> m (a, w) -- | Evaluate a computation with the given initial state and environment, -- returning the final state and output, discarding the final value. execRWST :: (Monad m) => RWST r w s m a -> r -> s -> m (s, w) -- | Map the inner computation using the given function. -- --

runRWST (mapRWST f m) r s = f (runRWST m
--   r s)

mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b -- | withRWST f m executes action m with an -- initial environment and state modified by applying f. -- --

runRWST (withRWST f m) r s = uncurry
--   (runRWST m) (f r s)

withRWST :: (r' -> s -> (r, s)) -> RWST r w s m a -> RWST r' w s m a -- | Constructor for computations in the reader monad (equivalent to -- asks). reader :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a -- | Fetch the value of the environment. ask :: (Monoid w, Monad m) => RWST r w s m r -- | Execute a computation in a modified environment -- --

runRWST (local f m) r s = runRWST m (f
--   r) s

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a -- | Retrieve a function of the current environment. -- --

```
asks f = liftM f ask
```

asks :: (Monoid w, Monad m) => (r -> a) -> RWST r w s m a -- | Construct a writer computation from a (result, output) pair. writer :: (Monad m) => (a, w) -> RWST r w s m a -- | tell w is an action that produces the output -- w. tell :: (Monad m) => w -> RWST r w s m () -- | listen m is an action that executes the action -- m and adds its output to the value of the computation. -- --

runRWST (listen m) r s = liftM (\ (a, w)
--   -> ((a, w), w)) (runRWST m r s)

listen :: (Monad m) => RWST r w s m a -> RWST r w s m (a, w) -- | listens f m is an action that executes the action -- m and adds the result of applying f to the output to -- the value of the computation. -- --

listens f m = liftM (id *** f) (listen
--   m)

runRWST (listens f m) r s = liftM (\ (a,
--   w) -> ((a, f w), w)) (runRWST m r s)

listens :: (Monad m) => (w -> b) -> RWST r w s m a -> RWST r w s m (a, b) -- | pass m is an action that executes the action -- m, which returns a value and a function, and returns the -- value, applying the function to the output. -- --

runRWST (pass m) r s = liftM (\ ((a, f),
--   w) -> (a, f w)) (runRWST m r s)

pass :: (Monad m) => RWST r w s m (a, w -> w) -> RWST r w s m a -- | censor f m is an action that executes the action -- m and applies the function f to its output, leaving -- the return value unchanged. -- --

censor f m = pass (liftM (\ x ->
--   (x,f)) m)

runRWST (censor f m) r s = liftM (\ (a,
--   w) -> (a, f w)) (runRWST m r s)

censor :: (Monad m) => (w -> w) -> RWST r w s m a -> RWST r w s m a -- | Construct a state monad computation from a state transformer function. state :: (Monoid w, Monad m) => (s -> (a, s)) -> RWST r w s m a -- | Fetch the current value of the state within the monad. get :: (Monoid w, Monad m) => RWST r w s m s -- | put s sets the state within the monad to s. put :: (Monoid w, Monad m) => s -> RWST r w s m () -- | modify f is an action that updates the state to the -- result of applying f to the current state. -- --

```
modify f = get >>= (put .
--   f)
```

modify :: (Monoid w, Monad m) => (s -> s) -> RWST r w s m () -- | Get a specific component of the state, using a projection function -- supplied. -- --

```
gets f = liftM f get
```

gets :: (Monoid w, Monad m) => (s -> a) -> RWST r w s m a -- | Uniform lifting of a callCC operation to the new monad. This -- version rolls back to the original state on entering the continuation. liftCallCC :: (Monoid w) => CallCC m (a, s, w) (b, s, w) -> CallCC (RWST r w s m) a b -- | In-situ lifting of a callCC operation to the new monad. This -- version uses the current state on entering the continuation. liftCallCC' :: (Monoid w) => CallCC m (a, s, w) (b, s, w) -> CallCC (RWST r w s m) a b -- | Lift a catchE operation to the new monad. liftCatch :: Catch e m (a, s, w) -> Catch e (RWST r w s m) a instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.RWS.Lazy.RWST r w s m) instance (GHC.Base.Monoid w, GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.RWS.Lazy.RWST r w s m) instance (GHC.Base.Monoid w, GHC.Base.Functor m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.RWS.Lazy.RWST r w s m) instance (GHC.Base.Monoid w, GHC.Base.Monad m) => GHC.Base.Monad (Control.Monad.Trans.RWS.Lazy.RWST r w s m) instance (GHC.Base.Monoid w, GHC.Base.MonadPlus m) => GHC.Base.MonadPlus (Control.Monad.Trans.RWS.Lazy.RWST r w s m) instance (GHC.Base.Monoid w, Control.Monad.Fix.MonadFix m) => Control.Monad.Fix.MonadFix (Control.Monad.Trans.RWS.Lazy.RWST r w s m) instance GHC.Base.Monoid w => Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.RWS.Lazy.RWST r w s) instance (GHC.Base.Monoid w, Control.Monad.IO.Class.MonadIO m) => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.RWS.Lazy.RWST r w s m) -- | A monad transformer that combines ReaderT, WriterT -- and StateT. This version is lazy; for a strict version, see -- Control.Monad.Trans.RWS.Strict, which has the same interface. module Control.Monad.Trans.RWS -- | A monad transformer that combines ReaderT, WriterT -- and StateT. This version is strict; for a lazy version with -- the same interface, see Control.Monad.Trans.RWS.Lazy. module Control.Monad.Trans.RWS.Strict -- | A monad containing an environment of type r, output of type -- w and an updatable state of type s. type RWS r w s = RWST r w s Identity -- | Construct an RWS computation from a function. (The inverse of -- runRWS.) rws :: (r -> s -> (a, s, w)) -> RWS r w s a -- | Unwrap an RWS computation as a function. (The inverse of rws.) runRWS :: RWS r w s a -> r -> s -> (a, s, w) -- | Evaluate a computation with the given initial state and environment, -- returning the final value and output, discarding the final state. evalRWS :: RWS r w s a -> r -> s -> (a, w) -- | Evaluate a computation with the given initial state and environment, -- returning the final state and output, discarding the final value. execRWS :: RWS r w s a -> r -> s -> (s, w) -- | Map the return value, final state and output of a computation using -- the given function. -- --

runRWS (mapRWS f m) r s = f (runRWS m r
--   s)

mapRWS :: ((a, s, w) -> (b, s, w')) -> RWS r w s a -> RWS r w' s b -- | withRWS f m executes action m with an initial -- environment and state modified by applying f. -- --

runRWS (withRWS f m) r s = uncurry
--   (runRWS m) (f r s)

runRWST (mapRWST f m) r s = f (runRWST m
--   r s)

mapRWST :: (m (a, s, w) -> n (b, s, w')) -> RWST r w s m a -> RWST r w' s n b -- | withRWST f m executes action m with an -- initial environment and state modified by applying f. -- --

runRWST (withRWST f m) r s = uncurry
--   (runRWST m) (f r s)

runRWST (local f m) r s = runRWST m (f
--   r) s

local :: (r -> r) -> RWST r w s m a -> RWST r w s m a -- | Retrieve a function of the current environment. -- --

```
asks f = liftM f ask
```

runRWST (listen m) r s = liftM (\ (a, w)
--   -> ((a, w), w)) (runRWST m r s)

listens f m = liftM (id *** f) (listen
--   m)

runRWST (listens f m) r s = liftM (\ (a,
--   w) -> ((a, f w), w)) (runRWST m r s)

runRWST (pass m) r s = liftM (\ ((a, f),
--   w) -> (a, f w)) (runRWST m r s)

censor f m = pass (liftM (\ x ->
--   (x,f)) m)

runRWST (censor f m) r s = liftM (\ (a,
--   w) -> (a, f w)) (runRWST m r s)

```
modify f = get >>= (put .
--   f)
```

modify :: (Monoid w, Monad m) => (s -> s) -> RWST r w s m () -- | Get a specific component of the state, using a projection function -- supplied. -- --

```
gets f = liftM f get
```

For a read-only state, see Control.Monad.Trans.Reader.
To accumulate a value without using it on the way, see -- Control.Monad.Trans.Writer.

-- -- In this version, sequencing of computations is lazy, so that for -- example the following produces a usable result: -- --

--   evalState (sequence $ repeat $ do { n <- get; put (n*2); return n }) 1
--

-- -- For a strict version with the same interface, see -- Control.Monad.Trans.State.Strict. module Control.Monad.Trans.State.Lazy -- | A state monad parameterized by the type s of the state to -- carry. -- -- The return function leaves the state unchanged, while -- >>= uses the final state of the first computation as -- the initial state of the second. type State s = StateT s Identity -- | Construct a state monad computation from a function. (The inverse of -- runState.) state :: (Monad m) => (s -> (a, s)) -> StateT s m a -- | Unwrap a state monad computation as a function. (The inverse of -- state.) runState :: State s a -> s -> (a, s) -- | Evaluate a state computation with the given initial state and return -- the final value, discarding the final state. -- --

```
evalState m s = fst (runState m
--   s)
```

evalState :: State s a -> s -> a -- | Evaluate a state computation with the given initial state and return -- the final state, discarding the final value. -- --

```
execState m s = snd (runState m
--   s)
```

execState :: State s a -> s -> s -- | Map both the return value and final state of a computation using the -- given function. -- --

runState (mapState f m) = f . runState
--   m

mapState :: ((a, s) -> (b, s)) -> State s a -> State s b -- | withState f m executes action m on a state -- modified by applying f. -- --

```
withState f m = modify f >> m
```

withState :: (s -> s) -> State s a -> State s a -- | A state transformer monad parameterized by: -- --

s - The state.
m - The inner monad.

-- -- The return function leaves the state unchanged, while -- >>= uses the final state of the first computation as -- the initial state of the second. newtype StateT s m a StateT :: (s -> m (a, s)) -> StateT s m a [runStateT] :: StateT s m a -> s -> m (a, s) -- | Evaluate a state computation with the given initial state and return -- the final value, discarding the final state. -- --

evalStateT m s = liftM fst
--   (runStateT m s)

evalStateT :: (Monad m) => StateT s m a -> s -> m a -- | Evaluate a state computation with the given initial state and return -- the final state, discarding the final value. -- --

execStateT m s = liftM snd
--   (runStateT m s)

execStateT :: (Monad m) => StateT s m a -> s -> m s -- | Map both the return value and final state of a computation using the -- given function. -- --

runStateT (mapStateT f m) = f .
--   runStateT m

mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b -- | withStateT f m executes action m on a state -- modified by applying f. -- --

```
withStateT f m = modify f >> m
```

withStateT :: (s -> s) -> StateT s m a -> StateT s m a -- | Fetch the current value of the state within the monad. get :: (Monad m) => StateT s m s -- | put s sets the state within the monad to s. put :: (Monad m) => s -> StateT s m () -- | modify f is an action that updates the state to the -- result of applying f to the current state. -- --

```
modify f = get >>= (put .
--   f)
```

modify :: (Monad m) => (s -> s) -> StateT s m () -- | A variant of modify in which the computation is strict in the -- new state. -- --

```
modify' f = get >>= (($!)
--   put . f)
```

modify' :: (Monad m) => (s -> s) -> StateT s m () -- | Get a specific component of the state, using a projection function -- supplied. -- --

```
gets f = liftM f get
```

gets :: (Monad m) => (s -> a) -> StateT s m a -- | Uniform lifting of a callCC operation to the new monad. This -- version rolls back to the original state on entering the continuation. liftCallCC :: CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b -- | In-situ lifting of a callCC operation to the new monad. This -- version uses the current state on entering the continuation. It does -- not satisfy the uniformity property (see -- Control.Monad.Signatures). liftCallCC' :: CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b -- | Lift a catchE operation to the new monad. liftCatch :: Catch e m (a, s) -> Catch e (StateT s m) a -- | Lift a listen operation to the new monad. liftListen :: (Monad m) => Listen w m (a, s) -> Listen w (StateT s m) a -- | Lift a pass operation to the new monad. liftPass :: (Monad m) => Pass w m (a, s) -> Pass w (StateT s m) a instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.State.Lazy.StateT s m) instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.State.Lazy.StateT s m) instance (GHC.Base.Functor m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.State.Lazy.StateT s m) instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.State.Lazy.StateT s m) instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.State.Lazy.StateT s m) instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.State.Lazy.StateT s m) instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.State.Lazy.StateT s) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.State.Lazy.StateT s m) -- | State monads, passing an updatable state through a computation. -- -- Some computations may not require the full power of state -- transformers: -- --

For a read-only state, see Control.Monad.Trans.Reader.
To accumulate a value without using it on the way, see -- Control.Monad.Trans.Writer.

-- -- This version is lazy; for a strict version, see -- Control.Monad.Trans.State.Strict, which has the same interface. module Control.Monad.Trans.State -- | Strict state monads, passing an updatable state through a computation. -- See below for examples. -- -- Some computations may not require the full power of state -- transformers: -- --

For a read-only state, see Control.Monad.Trans.Reader.
To accumulate a value without using it on the way, see -- Control.Monad.Trans.Writer.

-- -- In this version, sequencing of computations is strict (but -- computations are not strict in the state unless you force it with -- seq or the like). For a lazy version with the same interface, -- see Control.Monad.Trans.State.Lazy. module Control.Monad.Trans.State.Strict -- | A state monad parameterized by the type s of the state to -- carry. -- -- The return function leaves the state unchanged, while -- >>= uses the final state of the first computation as -- the initial state of the second. type State s = StateT s Identity -- | Construct a state monad computation from a function. (The inverse of -- runState.) state :: (Monad m) => (s -> (a, s)) -> StateT s m a -- | Unwrap a state monad computation as a function. (The inverse of -- state.) runState :: State s a -> s -> (a, s) -- | Evaluate a state computation with the given initial state and return -- the final value, discarding the final state. -- --

```
evalState m s = fst (runState m
--   s)
```

evalState :: State s a -> s -> a -- | Evaluate a state computation with the given initial state and return -- the final state, discarding the final value. -- --

```
execState m s = snd (runState m
--   s)
```

execState :: State s a -> s -> s -- | Map both the return value and final state of a computation using the -- given function. -- --

runState (mapState f m) = f . runState
--   m

mapState :: ((a, s) -> (b, s)) -> State s a -> State s b -- | withState f m executes action m on a state -- modified by applying f. -- --

```
withState f m = modify f >> m
```

withState :: (s -> s) -> State s a -> State s a -- | A state transformer monad parameterized by: -- --

s - The state.
m - The inner monad.

evalStateT m s = liftM fst
--   (runStateT m s)

evalStateT :: (Monad m) => StateT s m a -> s -> m a -- | Evaluate a state computation with the given initial state and return -- the final state, discarding the final value. -- --

execStateT m s = liftM snd
--   (runStateT m s)

execStateT :: (Monad m) => StateT s m a -> s -> m s -- | Map both the return value and final state of a computation using the -- given function. -- --

runStateT (mapStateT f m) = f .
--   runStateT m

mapStateT :: (m (a, s) -> n (b, s)) -> StateT s m a -> StateT s n b -- | withStateT f m executes action m on a state -- modified by applying f. -- --

```
withStateT f m = modify f >> m
```

```
modify f = get >>= (put .
--   f)
```

modify :: (Monad m) => (s -> s) -> StateT s m () -- | A variant of modify in which the computation is strict in the -- new state. -- --

```
modify' f = get >>= (($!)
--   put . f)
```

modify' :: (Monad m) => (s -> s) -> StateT s m () -- | Get a specific component of the state, using a projection function -- supplied. -- --

```
gets f = liftM f get
```

gets :: (Monad m) => (s -> a) -> StateT s m a -- | Uniform lifting of a callCC operation to the new monad. This -- version rolls back to the original state on entering the continuation. liftCallCC :: CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b -- | In-situ lifting of a callCC operation to the new monad. This -- version uses the current state on entering the continuation. It does -- not satisfy the uniformity property (see -- Control.Monad.Signatures). liftCallCC' :: CallCC m (a, s) (b, s) -> CallCC (StateT s m) a b -- | Lift a catchE operation to the new monad. liftCatch :: Catch e m (a, s) -> Catch e (StateT s m) a -- | Lift a listen operation to the new monad. liftListen :: (Monad m) => Listen w m (a, s) -> Listen w (StateT s m) a -- | Lift a pass operation to the new monad. liftPass :: (Monad m) => Pass w m (a, s) -> Pass w (StateT s m) a instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.State.Strict.StateT s m) instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.State.Strict.StateT s m) instance (GHC.Base.Functor m, GHC.Base.MonadPlus m) => GHC.Base.Alternative (Control.Monad.Trans.State.Strict.StateT s m) instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.State.Strict.StateT s m) instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.State.Strict.StateT s m) instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.State.Strict.StateT s m) instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.State.Strict.StateT s) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.State.Strict.StateT s m) -- | Liftings of the Prelude classes Eq, Ord, Read and -- Show to unary and binary type constructors. -- -- These classes are needed to express the constraints on arguments of -- transformers in portable Haskell. Thus for a new transformer -- T, one might write instances like -- --

--   instance (Eq1 f) => Eq1 (T f) where ...
--   instance (Ord1 f) => Ord1 (T f) where ...
--   instance (Read1 f) => Read1 (T f) where ...
--   instance (Show1 f) => Show1 (T f) where ...
--

-- -- If these instances can be defined, defining instances of the base -- classes is mechanical: -- --

--   instance (Eq1 f, Eq a) => Eq (T f a) where (==) = eq1
--   instance (Ord1 f, Ord a) => Ord (T f a) where compare = compare1
--   instance (Read1 f, Read a) => Read (T f a) where readsPrec = readsPrec1
--   instance (Show1 f, Show a) => Show (T f a) where showsPrec = showsPrec1
--

module Data.Functor.Classes -- | Lifting of the Eq class to unary type constructors. class Eq1 f -- | Lift an equality test through the type constructor. -- -- The function will usually be applied to an equality function, but the -- more general type ensures that the implementation uses it to compare -- elements of the first container with elements of the second. liftEq :: Eq1 f => (a -> b -> Bool) -> f a -> f b -> Bool -- | Lift the standard (==) function through the type -- constructor. eq1 :: (Eq1 f, Eq a) => f a -> f a -> Bool -- | Lifting of the Ord class to unary type constructors. class (Eq1 f) => Ord1 f -- | Lift a compare function through the type constructor. -- -- The function will usually be applied to a comparison function, but the -- more general type ensures that the implementation uses it to compare -- elements of the first container with elements of the second. liftCompare :: Ord1 f => (a -> b -> Ordering) -> f a -> f b -> Ordering -- | Lift the standard compare function through the type -- constructor. compare1 :: (Ord1 f, Ord a) => f a -> f a -> Ordering -- | Lifting of the Read class to unary type constructors. class Read1 f where liftReadList rp rl = readListWith (liftReadsPrec rp rl 0) -- | readsPrec function for an application of the type constructor -- based on readsPrec and readList functions for the -- argument type. liftReadsPrec :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> Int -> ReadS (f a) -- | readList function for an application of the type constructor -- based on readsPrec and readList functions for the -- argument type. The default implementation using standard list syntax -- is correct for most types. liftReadList :: Read1 f => (Int -> ReadS a) -> ReadS [a] -> ReadS [f a] -- | Lift the standard readsPrec and readList functions -- through the type constructor. readsPrec1 :: (Read1 f, Read a) => Int -> ReadS (f a) -- | Lifting of the Show class to unary type constructors. class Show1 f where liftShowList sp sl = showListWith (liftShowsPrec sp sl 0) -- | showsPrec function for an application of the type constructor -- based on showsPrec and showList functions for the -- argument type. liftShowsPrec :: Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> Int -> f a -> ShowS -- | showList function for an application of the type constructor -- based on showsPrec and showList functions for the -- argument type. The default implementation using standard list syntax -- is correct for most types. liftShowList :: Show1 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> [f a] -> ShowS -- | Lift the standard showsPrec and showList functions -- through the type constructor. showsPrec1 :: (Show1 f, Show a) => Int -> f a -> ShowS -- | Lifting of the Eq class to binary type constructors. class Eq2 f -- | Lift equality tests through the type constructor. -- -- The function will usually be applied to equality functions, but the -- more general type ensures that the implementation uses them to compare -- elements of the first container with elements of the second. liftEq2 :: Eq2 f => (a -> b -> Bool) -> (c -> d -> Bool) -> f a c -> f b d -> Bool -- | Lift the standard (==) function through the type -- constructor. eq2 :: (Eq2 f, Eq a, Eq b) => f a b -> f a b -> Bool -- | Lifting of the Ord class to binary type constructors. class (Eq2 f) => Ord2 f -- | Lift compare functions through the type constructor. -- -- The function will usually be applied to comparison functions, but the -- more general type ensures that the implementation uses them to compare -- elements of the first container with elements of the second. liftCompare2 :: Ord2 f => (a -> b -> Ordering) -> (c -> d -> Ordering) -> f a c -> f b d -> Ordering -- | Lift the standard compare function through the type -- constructor. compare2 :: (Ord2 f, Ord a, Ord b) => f a b -> f a b -> Ordering -- | Lifting of the Read class to binary type constructors. class Read2 f where liftReadList2 rp1 rl1 rp2 rl2 = readListWith (liftReadsPrec2 rp1 rl1 rp2 rl2 0) -- | readsPrec function for an application of the type constructor -- based on readsPrec and readList functions for the -- argument types. liftReadsPrec2 :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> Int -> ReadS (f a b) -- | readList function for an application of the type constructor -- based on readsPrec and readList functions for the -- argument types. The default implementation using standard list syntax -- is correct for most types. liftReadList2 :: Read2 f => (Int -> ReadS a) -> ReadS [a] -> (Int -> ReadS b) -> ReadS [b] -> ReadS [f a b] -- | Lift the standard readsPrec function through the type -- constructor. readsPrec2 :: (Read2 f, Read a, Read b) => Int -> ReadS (f a b) -- | Lifting of the Show class to binary type constructors. class Show2 f where liftShowList2 sp1 sl1 sp2 sl2 = showListWith (liftShowsPrec2 sp1 sl1 sp2 sl2 0) -- | showsPrec function for an application of the type constructor -- based on showsPrec and showList functions for the -- argument types. liftShowsPrec2 :: Show2 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> Int -> f a b -> ShowS -- | showList function for an application of the type constructor -- based on showsPrec and showList functions for the -- argument types. The default implementation using standard list syntax -- is correct for most types. liftShowList2 :: Show2 f => (Int -> a -> ShowS) -> ([a] -> ShowS) -> (Int -> b -> ShowS) -> ([b] -> ShowS) -> [f a b] -> ShowS -- | Lift the standard showsPrec function through the type -- constructor. showsPrec2 :: (Show2 f, Show a, Show b) => Int -> f a b -> ShowS -- | readsData p d is a parser for datatypes where each -- alternative begins with a data constructor. It parses the constructor -- and passes it to p. Parsers for various constructors can be -- constructed with readsUnary, readsUnary1 and -- readsBinary1, and combined with mappend from the -- Monoid class. readsData :: (String -> ReadS a) -> Int -> ReadS a -- | readsUnaryWith rp n c n' matches the name of a unary -- data constructor and then parses its argument using rp. readsUnaryWith :: (Int -> ReadS a) -> String -> (a -> t) -> String -> ReadS t -- | readsBinaryWith rp1 rp2 n c n' matches the name of a -- binary data constructor and then parses its arguments using -- rp1 and rp2 respectively. readsBinaryWith :: (Int -> ReadS a) -> (Int -> ReadS b) -> String -> (a -> b -> t) -> String -> ReadS t -- | showsUnaryWith sp n d x produces the string -- representation of a unary data constructor with name n and -- argument x, in precedence context d. showsUnaryWith :: (Int -> a -> ShowS) -> String -> Int -> a -> ShowS -- | showsBinaryWith sp1 sp2 n d x y produces the string -- representation of a binary data constructor with name n and -- arguments x and y, in precedence context d. showsBinaryWith :: (Int -> a -> ShowS) -> (Int -> b -> ShowS) -> String -> Int -> a -> b -> ShowS -- | readsUnary n c n' matches the name of a unary data -- constructor and then parses its argument using readsPrec. -- | Deprecated: Use readsUnaryWith to define liftReadsPrec readsUnary :: (Read a) => String -> (a -> t) -> String -> ReadS t -- | readsUnary1 n c n' matches the name of a unary data -- constructor and then parses its argument using readsPrec1. -- | Deprecated: Use readsUnaryWith to define liftReadsPrec readsUnary1 :: (Read1 f, Read a) => String -> (f a -> t) -> String -> ReadS t -- | readsBinary1 n c n' matches the name of a binary data -- constructor and then parses its arguments using readsPrec1. -- | Deprecated: Use readsBinaryWith to define liftReadsPrec readsBinary1 :: (Read1 f, Read1 g, Read a) => String -> (f a -> g a -> t) -> String -> ReadS t -- | showsUnary n d x produces the string representation of -- a unary data constructor with name n and argument x, -- in precedence context d. -- | Deprecated: Use showsUnaryWith to define liftShowsPrec showsUnary :: (Show a) => String -> Int -> a -> ShowS -- | showsUnary1 n d x produces the string representation -- of a unary data constructor with name n and argument -- x, in precedence context d. -- | Deprecated: Use showsUnaryWith to define liftShowsPrec showsUnary1 :: (Show1 f, Show a) => String -> Int -> f a -> ShowS -- | showsBinary1 n d x y produces the string -- representation of a binary data constructor with name n and -- arguments x and y, in precedence context d. -- | Deprecated: Use showsBinaryWith to define liftShowsPrec showsBinary1 :: (Show1 f, Show1 g, Show a) => String -> Int -> f a -> g a -> ShowS instance Data.Functor.Classes.Eq1 GHC.Base.Maybe instance Data.Functor.Classes.Ord1 GHC.Base.Maybe instance Data.Functor.Classes.Read1 GHC.Base.Maybe instance Data.Functor.Classes.Show1 GHC.Base.Maybe instance Data.Functor.Classes.Eq1 [] instance Data.Functor.Classes.Ord1 [] instance Data.Functor.Classes.Read1 [] instance Data.Functor.Classes.Show1 [] instance Data.Functor.Classes.Eq2 (,) instance Data.Functor.Classes.Ord2 (,) instance Data.Functor.Classes.Read2 (,) instance Data.Functor.Classes.Show2 (,) instance GHC.Classes.Eq a => Data.Functor.Classes.Eq1 ((,) a) instance GHC.Classes.Ord a => Data.Functor.Classes.Ord1 ((,) a) instance GHC.Read.Read a => Data.Functor.Classes.Read1 ((,) a) instance GHC.Show.Show a => Data.Functor.Classes.Show1 ((,) a) instance Data.Functor.Classes.Eq2 Data.Either.Either instance Data.Functor.Classes.Ord2 Data.Either.Either instance Data.Functor.Classes.Read2 Data.Either.Either instance Data.Functor.Classes.Show2 Data.Either.Either instance GHC.Classes.Eq a => Data.Functor.Classes.Eq1 (Data.Either.Either a) instance GHC.Classes.Ord a => Data.Functor.Classes.Ord1 (Data.Either.Either a) instance GHC.Read.Read a => Data.Functor.Classes.Read1 (Data.Either.Either a) instance GHC.Show.Show a => Data.Functor.Classes.Show1 (Data.Either.Either a) instance Data.Functor.Classes.Eq1 Data.Functor.Identity.Identity instance Data.Functor.Classes.Ord1 Data.Functor.Identity.Identity instance Data.Functor.Classes.Read1 Data.Functor.Identity.Identity instance Data.Functor.Classes.Show1 Data.Functor.Identity.Identity instance Data.Functor.Classes.Eq2 Control.Applicative.Const instance Data.Functor.Classes.Ord2 Control.Applicative.Const instance Data.Functor.Classes.Read2 Control.Applicative.Const instance Data.Functor.Classes.Show2 Control.Applicative.Const instance GHC.Classes.Eq a => Data.Functor.Classes.Eq1 (Control.Applicative.Const a) instance GHC.Classes.Ord a => Data.Functor.Classes.Ord1 (Control.Applicative.Const a) instance GHC.Read.Read a => Data.Functor.Classes.Read1 (Control.Applicative.Const a) instance GHC.Show.Show a => Data.Functor.Classes.Show1 (Control.Applicative.Const a) -- | The constant functor. module Data.Functor.Constant -- | Constant functor. newtype Constant a b Constant :: a -> Constant a b [getConstant] :: Constant a b -> a instance forall (k :: BOX) a (b :: k). GHC.Classes.Ord a => GHC.Classes.Ord (Data.Functor.Constant.Constant a b) instance forall (k :: BOX) a (b :: k). GHC.Classes.Eq a => GHC.Classes.Eq (Data.Functor.Constant.Constant a b) instance forall (k :: BOX) a (b :: k). GHC.Read.Read a => GHC.Read.Read (Data.Functor.Constant.Constant a b) instance forall (k :: BOX) a (b :: k). GHC.Show.Show a => GHC.Show.Show (Data.Functor.Constant.Constant a b) instance Data.Functor.Classes.Eq2 Data.Functor.Constant.Constant instance Data.Functor.Classes.Ord2 Data.Functor.Constant.Constant instance Data.Functor.Classes.Read2 Data.Functor.Constant.Constant instance Data.Functor.Classes.Show2 Data.Functor.Constant.Constant instance GHC.Classes.Eq a => Data.Functor.Classes.Eq1 (Data.Functor.Constant.Constant a) instance GHC.Classes.Ord a => Data.Functor.Classes.Ord1 (Data.Functor.Constant.Constant a) instance GHC.Read.Read a => Data.Functor.Classes.Read1 (Data.Functor.Constant.Constant a) instance GHC.Show.Show a => Data.Functor.Classes.Show1 (Data.Functor.Constant.Constant a) instance GHC.Base.Functor (Data.Functor.Constant.Constant a) instance Data.Foldable.Foldable (Data.Functor.Constant.Constant a) instance Data.Traversable.Traversable (Data.Functor.Constant.Constant a) instance GHC.Base.Monoid a => GHC.Base.Applicative (Data.Functor.Constant.Constant a) instance forall (k :: BOX) a (b :: k). GHC.Base.Monoid a => GHC.Base.Monoid (Data.Functor.Constant.Constant a b) instance Data.Bifunctor.Bifunctor Data.Functor.Constant.Constant -- | Adding a new kind of pure computation to an applicative functor. module Control.Applicative.Lift -- | Applicative functor formed by adding pure computations to a given -- applicative functor. data Lift f a Pure :: a -> Lift f a Other :: (f a) -> Lift f a -- | Projection to the other functor. unLift :: (Applicative f) => Lift f a -> f a -- | Apply a transformation to the other computation. mapLift :: (f a -> g a) -> Lift f a -> Lift g a -- | An applicative functor that collects a monoid (e.g. lists) of errors. -- A sequence of computations fails if any of its components do, but -- unlike monads made with ExceptT from -- Control.Monad.Trans.Except, these computations continue after -- an error, collecting all the errors. -- --

```
pure f <*> pure x = pure (f
--   x)
```
```
pure f <*> failure e =
--   failure e
```
```
failure e <*> pure x =
--   failure e
```

failure e1 <*> failure e2 =
--   failure (e1 <> e2)

type Errors e = Lift (Constant e) -- | Extractor for computations with accumulating errors. -- --

```
runErrors (pure x) = Right x
```
```
runErrors (failure e) = Left
--   e
```

runErrors :: Errors e a -> Either e a -- | Report an error. failure :: e -> Errors e a instance Data.Functor.Classes.Eq1 f => Data.Functor.Classes.Eq1 (Control.Applicative.Lift.Lift f) instance Data.Functor.Classes.Ord1 f => Data.Functor.Classes.Ord1 (Control.Applicative.Lift.Lift f) instance Data.Functor.Classes.Read1 f => Data.Functor.Classes.Read1 (Control.Applicative.Lift.Lift f) instance Data.Functor.Classes.Show1 f => Data.Functor.Classes.Show1 (Control.Applicative.Lift.Lift f) instance (Data.Functor.Classes.Eq1 f, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Applicative.Lift.Lift f a) instance (Data.Functor.Classes.Ord1 f, GHC.Classes.Ord a) => GHC.Classes.Ord (Control.Applicative.Lift.Lift f a) instance (Data.Functor.Classes.Read1 f, GHC.Read.Read a) => GHC.Read.Read (Control.Applicative.Lift.Lift f a) instance (Data.Functor.Classes.Show1 f, GHC.Show.Show a) => GHC.Show.Show (Control.Applicative.Lift.Lift f a) instance GHC.Base.Functor f => GHC.Base.Functor (Control.Applicative.Lift.Lift f) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Control.Applicative.Lift.Lift f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Control.Applicative.Lift.Lift f) instance GHC.Base.Applicative f => GHC.Base.Applicative (Control.Applicative.Lift.Lift f) instance GHC.Base.Alternative f => GHC.Base.Alternative (Control.Applicative.Lift.Lift f) -- | This monad transformer extends a monad with the ability throw -- exceptions. -- -- A sequence of actions terminates normally, producing a value, only if -- none of the actions in the sequence throws an exception. If one throws -- an exception, the rest of the sequence is skipped and the composite -- action exits with that exception. -- -- If the value of the exception is not required, the variant in -- Control.Monad.Trans.Maybe may be used instead. module Control.Monad.Trans.Except -- | The parameterizable exception monad. -- -- Computations are either exceptions or normal values. -- -- The return function returns a normal value, while -- >>= exits on the first exception. For a variant that -- continues after an error and collects all the errors, see -- Errors. type Except e = ExceptT e Identity -- | Constructor for computations in the exception monad. (The inverse of -- runExcept). except :: Either e a -> Except e a -- | Extractor for computations in the exception monad. (The inverse of -- except). runExcept :: Except e a -> Either e a -- | Map the unwrapped computation using the given function. -- --

runExcept (mapExcept f m) = f (runExcept
--   m)

mapExcept :: (Either e a -> Either e' b) -> Except e a -> Except e' b -- | Transform any exceptions thrown by the computation using the given -- function (a specialization of withExceptT). withExcept :: (e -> e') -> Except e a -> Except e' a -- | A monad transformer that adds exceptions to other monads. -- -- ExceptT constructs a monad parameterized over two things: -- --

e - The exception type.
m - The inner monad.

-- -- The return function yields a computation that produces the -- given value, while >>= sequences two subcomputations, -- exiting on the first exception. newtype ExceptT e m a ExceptT :: (m (Either e a)) -> ExceptT e m a -- | The inverse of ExceptT. runExceptT :: ExceptT e m a -> m (Either e a) -- | Map the unwrapped computation using the given function. -- --

runExceptT (mapExceptT f m) = f
--   (runExceptT m)

mapExceptT :: (m (Either e a) -> n (Either e' b)) -> ExceptT e m a -> ExceptT e' n b -- | Transform any exceptions thrown by the computation using the given -- function. withExceptT :: (Functor m) => (e -> e') -> ExceptT e m a -> ExceptT e' m a -- | Signal an exception value e. -- --

runExceptT (throwE e) = return
--   (Left e)

```
throwE e >>= m = throwE e
```

throwE :: (Monad m) => e -> ExceptT e m a -- | Handle an exception. -- --

```
catchE h (lift m) = lift m
```
```
catchE h (throwE e) = h e
```

catchE :: (Monad m) => ExceptT e m a -> (e -> ExceptT e' m a) -> ExceptT e' m a -- | Lift a callCC operation to the new monad. liftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ExceptT e m) a b -- | Lift a listen operation to the new monad. liftListen :: (Monad m) => Listen w m (Either e a) -> Listen w (ExceptT e m) a -- | Lift a pass operation to the new monad. liftPass :: (Monad m) => Pass w m (Either e a) -> Pass w (ExceptT e m) a instance (GHC.Classes.Eq e, Data.Functor.Classes.Eq1 m) => Data.Functor.Classes.Eq1 (Control.Monad.Trans.Except.ExceptT e m) instance (GHC.Classes.Ord e, Data.Functor.Classes.Ord1 m) => Data.Functor.Classes.Ord1 (Control.Monad.Trans.Except.ExceptT e m) instance (GHC.Read.Read e, Data.Functor.Classes.Read1 m) => Data.Functor.Classes.Read1 (Control.Monad.Trans.Except.ExceptT e m) instance (GHC.Show.Show e, Data.Functor.Classes.Show1 m) => Data.Functor.Classes.Show1 (Control.Monad.Trans.Except.ExceptT e m) instance (GHC.Classes.Eq e, Data.Functor.Classes.Eq1 m, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Monad.Trans.Except.ExceptT e m a) instance (GHC.Classes.Ord e, Data.Functor.Classes.Ord1 m, GHC.Classes.Ord a) => GHC.Classes.Ord (Control.Monad.Trans.Except.ExceptT e m a) instance (GHC.Read.Read e, Data.Functor.Classes.Read1 m, GHC.Read.Read a) => GHC.Read.Read (Control.Monad.Trans.Except.ExceptT e m a) instance (GHC.Show.Show e, Data.Functor.Classes.Show1 m, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Trans.Except.ExceptT e m a) instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Except.ExceptT e m) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Control.Monad.Trans.Except.ExceptT e f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Control.Monad.Trans.Except.ExceptT e f) instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.Except.ExceptT e m) instance (GHC.Base.Functor m, GHC.Base.Monad m, GHC.Base.Monoid e) => GHC.Base.Alternative (Control.Monad.Trans.Except.ExceptT e m) instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.Except.ExceptT e m) instance (GHC.Base.Monad m, GHC.Base.Monoid e) => GHC.Base.MonadPlus (Control.Monad.Trans.Except.ExceptT e m) instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Except.ExceptT e m) instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Except.ExceptT e) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Except.ExceptT e m) instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Control.Monad.Trans.Except.ExceptT e m) -- | This monad transformer adds the ability to fail or throw exceptions to -- a monad. -- -- A sequence of actions succeeds, producing a value, only if all the -- actions in the sequence are successful. If one fails with an error, -- the rest of the sequence is skipped and the composite action fails -- with that error. -- -- If the value of the error is not required, the variant in -- Control.Monad.Trans.Maybe may be used instead. -- -- Note: This module will be removed in a future release. Instead, -- use Control.Monad.Trans.Except, which does not restrict the -- exception type, and also includes a base exception monad. -- | Deprecated: Use Control.Monad.Trans.Except instead module Control.Monad.Trans.Error -- | An exception to be thrown. -- -- Minimal complete definition: noMsg or strMsg. class Error a where noMsg = strMsg "" strMsg _ = noMsg -- | Creates an exception without a message. The default implementation is -- strMsg "". noMsg :: Error a => a -- | Creates an exception with a message. The default implementation of -- strMsg s is noMsg. strMsg :: Error a => String -> a -- | Workaround so that we can have a Haskell 98 instance Error -- String. class ErrorList a listMsg :: ErrorList a => String -> [a] -- | The error monad transformer. It can be used to add error handling to -- other monads. -- -- The ErrorT Monad structure is parameterized over two things: -- --

e - The error type.
m - The inner monad.

-- -- The return function yields a successful computation, while -- >>= sequences two subcomputations, failing on the first -- error. newtype ErrorT e m a ErrorT :: m (Either e a) -> ErrorT e m a [runErrorT] :: ErrorT e m a -> m (Either e a) -- | Map the unwrapped computation using the given function. -- --

runErrorT (mapErrorT f m) = f (runErrorT
--   m)

mapErrorT :: (m (Either e a) -> n (Either e' b)) -> ErrorT e m a -> ErrorT e' n b -- | Signal an error value e. -- --

runErrorT (throwError e) = return
--   (Left e)

```
throwError e >>= m = throwError
--   e
```

throwError :: (Monad m) => e -> ErrorT e m a -- | Handle an error. -- --

```
catchError h (lift m) = lift
--   m
```
```
catchError h (throwError e) = h e
```

catchError :: (Monad m) => ErrorT e m a -> (e -> ErrorT e m a) -> ErrorT e m a -- | Lift a callCC operation to the new monad. liftCallCC :: CallCC m (Either e a) (Either e b) -> CallCC (ErrorT e m) a b -- | Lift a listen operation to the new monad. liftListen :: (Monad m) => Listen w m (Either e a) -> Listen w (ErrorT e m) a -- | Lift a pass operation to the new monad. liftPass :: (Monad m) => Pass w m (Either e a) -> Pass w (ErrorT e m) a instance GHC.Base.MonadPlus GHC.Types.IO instance GHC.Base.Alternative GHC.Types.IO instance Control.Monad.Trans.Error.Error e => GHC.Base.Alternative (Data.Either.Either e) instance Control.Monad.Trans.Error.Error e => GHC.Base.MonadPlus (Data.Either.Either e) instance Control.Monad.Trans.Error.Error GHC.IO.Exception.IOException instance Control.Monad.Trans.Error.ErrorList a => Control.Monad.Trans.Error.Error [a] instance Control.Monad.Trans.Error.ErrorList GHC.Types.Char instance (GHC.Classes.Eq e, Data.Functor.Classes.Eq1 m) => Data.Functor.Classes.Eq1 (Control.Monad.Trans.Error.ErrorT e m) instance (GHC.Classes.Ord e, Data.Functor.Classes.Ord1 m) => Data.Functor.Classes.Ord1 (Control.Monad.Trans.Error.ErrorT e m) instance (GHC.Read.Read e, Data.Functor.Classes.Read1 m) => Data.Functor.Classes.Read1 (Control.Monad.Trans.Error.ErrorT e m) instance (GHC.Show.Show e, Data.Functor.Classes.Show1 m) => Data.Functor.Classes.Show1 (Control.Monad.Trans.Error.ErrorT e m) instance (GHC.Classes.Eq e, Data.Functor.Classes.Eq1 m, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Monad.Trans.Error.ErrorT e m a) instance (GHC.Classes.Ord e, Data.Functor.Classes.Ord1 m, GHC.Classes.Ord a) => GHC.Classes.Ord (Control.Monad.Trans.Error.ErrorT e m a) instance (GHC.Read.Read e, Data.Functor.Classes.Read1 m, GHC.Read.Read a) => GHC.Read.Read (Control.Monad.Trans.Error.ErrorT e m a) instance (GHC.Show.Show e, Data.Functor.Classes.Show1 m, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Trans.Error.ErrorT e m a) instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Error.ErrorT e m) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Control.Monad.Trans.Error.ErrorT e f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Control.Monad.Trans.Error.ErrorT e f) instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.Error.ErrorT e m) instance (GHC.Base.Functor m, GHC.Base.Monad m, Control.Monad.Trans.Error.Error e) => GHC.Base.Alternative (Control.Monad.Trans.Error.ErrorT e m) instance (GHC.Base.Monad m, Control.Monad.Trans.Error.Error e) => GHC.Base.Monad (Control.Monad.Trans.Error.ErrorT e m) instance (GHC.Base.Monad m, Control.Monad.Trans.Error.Error e) => GHC.Base.MonadPlus (Control.Monad.Trans.Error.ErrorT e m) instance (Control.Monad.Fix.MonadFix m, Control.Monad.Trans.Error.Error e) => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Error.ErrorT e m) instance Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Error.ErrorT e) instance (Control.Monad.Trans.Error.Error e, Control.Monad.IO.Class.MonadIO m) => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Error.ErrorT e m) -- | The identity monad transformer. -- -- This is useful for functions parameterized by a monad transformer. module Control.Monad.Trans.Identity -- | The trivial monad transformer, which maps a monad to an equivalent -- monad. newtype IdentityT f a IdentityT :: f a -> IdentityT f a [runIdentityT] :: IdentityT f a -> f a -- | Lift a unary operation to the new monad. mapIdentityT :: (m a -> n b) -> IdentityT m a -> IdentityT n b -- | Lift a catchE operation to the new monad. liftCatch :: Catch e m a -> Catch e (IdentityT m) a -- | Lift a callCC operation to the new monad. liftCallCC :: CallCC m a b -> CallCC (IdentityT m) a b instance Data.Functor.Classes.Eq1 f => Data.Functor.Classes.Eq1 (Control.Monad.Trans.Identity.IdentityT f) instance Data.Functor.Classes.Ord1 f => Data.Functor.Classes.Ord1 (Control.Monad.Trans.Identity.IdentityT f) instance Data.Functor.Classes.Read1 f => Data.Functor.Classes.Read1 (Control.Monad.Trans.Identity.IdentityT f) instance Data.Functor.Classes.Show1 f => Data.Functor.Classes.Show1 (Control.Monad.Trans.Identity.IdentityT f) instance (Data.Functor.Classes.Eq1 f, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Monad.Trans.Identity.IdentityT f a) instance (Data.Functor.Classes.Ord1 f, GHC.Classes.Ord a) => GHC.Classes.Ord (Control.Monad.Trans.Identity.IdentityT f a) instance (Data.Functor.Classes.Read1 f, GHC.Read.Read a) => GHC.Read.Read (Control.Monad.Trans.Identity.IdentityT f a) instance (Data.Functor.Classes.Show1 f, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Trans.Identity.IdentityT f a) instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Identity.IdentityT m) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Control.Monad.Trans.Identity.IdentityT f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Control.Monad.Trans.Identity.IdentityT f) instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Monad.Trans.Identity.IdentityT m) instance GHC.Base.Alternative m => GHC.Base.Alternative (Control.Monad.Trans.Identity.IdentityT m) instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.Identity.IdentityT m) instance GHC.Base.MonadPlus m => GHC.Base.MonadPlus (Control.Monad.Trans.Identity.IdentityT m) instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Identity.IdentityT m) instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Identity.IdentityT m) instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Control.Monad.Trans.Identity.IdentityT m) instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Trans.Identity.IdentityT -- | The ListT monad transformer, adding backtracking to a given monad, -- which must be commutative. module Control.Monad.Trans.List -- | Parameterizable list monad, with an inner monad. -- -- Note: this does not yield a monad unless the argument monad is -- commutative. newtype ListT m a ListT :: m [a] -> ListT m a [runListT] :: ListT m a -> m [a] -- | Map between ListT computations. -- --

runListT (mapListT f m) = f (runListT
--   m)

mapListT :: (m [a] -> n [b]) -> ListT m a -> ListT n b -- | Lift a callCC operation to the new monad. liftCallCC :: CallCC m [a] [b] -> CallCC (ListT m) a b -- | Lift a catchE operation to the new monad. liftCatch :: Catch e m [a] -> Catch e (ListT m) a instance Data.Functor.Classes.Eq1 m => Data.Functor.Classes.Eq1 (Control.Monad.Trans.List.ListT m) instance Data.Functor.Classes.Ord1 m => Data.Functor.Classes.Ord1 (Control.Monad.Trans.List.ListT m) instance Data.Functor.Classes.Read1 m => Data.Functor.Classes.Read1 (Control.Monad.Trans.List.ListT m) instance Data.Functor.Classes.Show1 m => Data.Functor.Classes.Show1 (Control.Monad.Trans.List.ListT m) instance (Data.Functor.Classes.Eq1 m, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Monad.Trans.List.ListT m a) instance (Data.Functor.Classes.Ord1 m, GHC.Classes.Ord a) => GHC.Classes.Ord (Control.Monad.Trans.List.ListT m a) instance (Data.Functor.Classes.Read1 m, GHC.Read.Read a) => GHC.Read.Read (Control.Monad.Trans.List.ListT m a) instance (Data.Functor.Classes.Show1 m, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Trans.List.ListT m a) instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.List.ListT m) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Control.Monad.Trans.List.ListT f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Control.Monad.Trans.List.ListT f) instance GHC.Base.Applicative m => GHC.Base.Applicative (Control.Monad.Trans.List.ListT m) instance GHC.Base.Applicative m => GHC.Base.Alternative (Control.Monad.Trans.List.ListT m) instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.List.ListT m) instance GHC.Base.Monad m => GHC.Base.MonadPlus (Control.Monad.Trans.List.ListT m) instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Trans.List.ListT instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.List.ListT m) instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Control.Monad.Trans.List.ListT m) -- | The MaybeT monad transformer extends a monad with the ability -- to exit the computation without returning a value. -- -- A sequence of actions produces a value only if all the actions in the -- sequence do. If one exits, the rest of the sequence is skipped and the -- composite action exits. -- -- For a variant allowing a range of exception values, see -- Control.Monad.Trans.Except. module Control.Monad.Trans.Maybe -- | The parameterizable maybe monad, obtained by composing an arbitrary -- monad with the Maybe monad. -- -- Computations are actions that may produce a value or exit. -- -- The return function yields a computation that produces that -- value, while >>= sequences two subcomputations, exiting -- if either computation does. newtype MaybeT m a MaybeT :: m (Maybe a) -> MaybeT m a [runMaybeT] :: MaybeT m a -> m (Maybe a) -- | Transform the computation inside a MaybeT. -- --

runMaybeT (mapMaybeT f m) = f (runMaybeT
--   m)

mapMaybeT :: (m (Maybe a) -> n (Maybe b)) -> MaybeT m a -> MaybeT n b -- | Convert a MaybeT computation to ExceptT, with a default -- exception value. maybeToExceptT :: (Functor m) => e -> MaybeT m a -> ExceptT e m a -- | Convert a ExceptT computation to MaybeT, discarding the -- value of any exception. exceptToMaybeT :: (Functor m) => ExceptT e m a -> MaybeT m a -- | Lift a callCC operation to the new monad. liftCallCC :: CallCC m (Maybe a) (Maybe b) -> CallCC (MaybeT m) a b -- | Lift a catchE operation to the new monad. liftCatch :: Catch e m (Maybe a) -> Catch e (MaybeT m) a -- | Lift a listen operation to the new monad. liftListen :: (Monad m) => Listen w m (Maybe a) -> Listen w (MaybeT m) a -- | Lift a pass operation to the new monad. liftPass :: (Monad m) => Pass w m (Maybe a) -> Pass w (MaybeT m) a instance Data.Functor.Classes.Eq1 m => Data.Functor.Classes.Eq1 (Control.Monad.Trans.Maybe.MaybeT m) instance Data.Functor.Classes.Ord1 m => Data.Functor.Classes.Ord1 (Control.Monad.Trans.Maybe.MaybeT m) instance Data.Functor.Classes.Read1 m => Data.Functor.Classes.Read1 (Control.Monad.Trans.Maybe.MaybeT m) instance Data.Functor.Classes.Show1 m => Data.Functor.Classes.Show1 (Control.Monad.Trans.Maybe.MaybeT m) instance (Data.Functor.Classes.Eq1 m, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Monad.Trans.Maybe.MaybeT m a) instance (Data.Functor.Classes.Ord1 m, GHC.Classes.Ord a) => GHC.Classes.Ord (Control.Monad.Trans.Maybe.MaybeT m a) instance (Data.Functor.Classes.Read1 m, GHC.Read.Read a) => GHC.Read.Read (Control.Monad.Trans.Maybe.MaybeT m a) instance (Data.Functor.Classes.Show1 m, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Trans.Maybe.MaybeT m a) instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Maybe.MaybeT m) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Control.Monad.Trans.Maybe.MaybeT f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Control.Monad.Trans.Maybe.MaybeT f) instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Applicative (Control.Monad.Trans.Maybe.MaybeT m) instance (GHC.Base.Functor m, GHC.Base.Monad m) => GHC.Base.Alternative (Control.Monad.Trans.Maybe.MaybeT m) instance GHC.Base.Monad m => GHC.Base.Monad (Control.Monad.Trans.Maybe.MaybeT m) instance GHC.Base.Monad m => GHC.Base.MonadPlus (Control.Monad.Trans.Maybe.MaybeT m) instance Control.Monad.Fix.MonadFix m => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Maybe.MaybeT m) instance Control.Monad.Trans.Class.MonadTrans Control.Monad.Trans.Maybe.MaybeT instance Control.Monad.IO.Class.MonadIO m => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Maybe.MaybeT m) instance Control.Monad.Zip.MonadZip m => Control.Monad.Zip.MonadZip (Control.Monad.Trans.Maybe.MaybeT m) -- | The lazy WriterT monad transformer, which adds collection of -- outputs (such as a count or string output) to a given monad. -- -- This monad transformer provides only limited access to the output -- during the computation. For more general access, use -- Control.Monad.Trans.State instead. -- -- This version builds its output lazily; for a strict version with the -- same interface, see Control.Monad.Trans.Writer.Strict. module Control.Monad.Trans.Writer.Lazy -- | A writer monad parameterized by the type w of output to -- accumulate. -- -- The return function produces the output mempty, while -- >>= combines the outputs of the subcomputations using -- mappend. type Writer w = WriterT w Identity -- | Construct a writer computation from a (result, output) pair. (The -- inverse of runWriter.) writer :: (Monad m) => (a, w) -> WriterT w m a -- | Unwrap a writer computation as a (result, output) pair. (The inverse -- of writer.) runWriter :: Writer w a -> (a, w) -- | Extract the output from a writer computation. -- --

```
execWriter m = snd (runWriter
--   m)
```

execWriter :: Writer w a -> w -- | Map both the return value and output of a computation using the given -- function. -- --

runWriter (mapWriter f m) = f (runWriter
--   m)

mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b -- | A writer monad parameterized by: -- --

w - the output to accumulate.
m - The inner monad.

-- -- The return function produces the output mempty, while -- >>= combines the outputs of the subcomputations using -- mappend. newtype WriterT w m a WriterT :: m (a, w) -> WriterT w m a [runWriterT] :: WriterT w m a -> m (a, w) -- | Extract the output from a writer computation. -- --

execWriterT m = liftM snd
--   (runWriterT m)

execWriterT :: (Monad m) => WriterT w m a -> m w -- | Map both the return value and output of a computation using the given -- function. -- --

runWriterT (mapWriterT f m) = f
--   (runWriterT m)

mapWriterT :: (m (a, w) -> n (b, w')) -> WriterT w m a -> WriterT w' n b -- | tell w is an action that produces the output -- w. tell :: (Monad m) => w -> WriterT w m () -- | listen m is an action that executes the action -- m and adds its output to the value of the computation. -- --

runWriterT (listen m) = liftM (\ (a, w)
--   -> ((a, w), w)) (runWriterT m)

listen :: (Monad m) => WriterT w m a -> WriterT w m (a, w) -- | listens f m is an action that executes the action -- m and adds the result of applying f to the output to -- the value of the computation. -- --

listens f m = liftM (id *** f) (listen
--   m)

runWriterT (listens f m) = liftM (\ (a,
--   w) -> ((a, f w), w)) (runWriterT m)

listens :: (Monad m) => (w -> b) -> WriterT w m a -> WriterT w m (a, b) -- | pass m is an action that executes the action -- m, which returns a value and a function, and returns the -- value, applying the function to the output. -- --

runWriterT (pass m) = liftM (\ ((a, f),
--   w) -> (a, f w)) (runWriterT m)

pass :: (Monad m) => WriterT w m (a, w -> w) -> WriterT w m a -- | censor f m is an action that executes the action -- m and applies the function f to its output, leaving -- the return value unchanged. -- --

censor f m = pass (liftM (\ x ->
--   (x,f)) m)

runWriterT (censor f m) = liftM (\ (a,
--   w) -> (a, f w)) (runWriterT m)

```
execWriter m = snd (runWriter
--   m)
```

execWriter :: Writer w a -> w -- | Map both the return value and output of a computation using the given -- function. -- --

runWriter (mapWriter f m) = f (runWriter
--   m)

mapWriter :: ((a, w) -> (b, w')) -> Writer w a -> Writer w' b -- | A writer monad parameterized by: -- --

w - the output to accumulate.
m - The inner monad.

execWriterT m = liftM snd
--   (runWriterT m)

execWriterT :: (Monad m) => WriterT w m a -> m w -- | Map both the return value and output of a computation using the given -- function. -- --

runWriterT (mapWriterT f m) = f
--   (runWriterT m)

runWriterT (listen m) = liftM (\ (a, w)
--   -> ((a, w), w)) (runWriterT m)

listens f m = liftM (id *** f) (listen
--   m)

runWriterT (listens f m) = liftM (\ (a,
--   w) -> ((a, f w), w)) (runWriterT m)

runWriterT (pass m) = liftM (\ ((a, f),
--   w) -> (a, f w)) (runWriterT m)

censor f m = pass (liftM (\ x ->
--   (x,f)) m)

runWriterT (censor f m) = liftM (\ (a,
--   w) -> (a, f w)) (runWriterT m)

censor :: (Monad m) => (w -> w) -> WriterT w m a -> WriterT w m a -- | Lift a callCC operation to the new monad. liftCallCC :: (Monoid w) => CallCC m (a, w) (b, w) -> CallCC (WriterT w m) a b -- | Lift a catchE operation to the new monad. liftCatch :: Catch e m (a, w) -> Catch e (WriterT w m) a instance (GHC.Classes.Eq w, Data.Functor.Classes.Eq1 m) => Data.Functor.Classes.Eq1 (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Classes.Ord w, Data.Functor.Classes.Ord1 m) => Data.Functor.Classes.Ord1 (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Read.Read w, Data.Functor.Classes.Read1 m) => Data.Functor.Classes.Read1 (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Show.Show w, Data.Functor.Classes.Show1 m) => Data.Functor.Classes.Show1 (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Classes.Eq w, Data.Functor.Classes.Eq1 m, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Monad.Trans.Writer.Strict.WriterT w m a) instance (GHC.Classes.Ord w, Data.Functor.Classes.Ord1 m, GHC.Classes.Ord a) => GHC.Classes.Ord (Control.Monad.Trans.Writer.Strict.WriterT w m a) instance (GHC.Read.Read w, Data.Functor.Classes.Read1 m, GHC.Read.Read a) => GHC.Read.Read (Control.Monad.Trans.Writer.Strict.WriterT w m a) instance (GHC.Show.Show w, Data.Functor.Classes.Show1 m, GHC.Show.Show a) => GHC.Show.Show (Control.Monad.Trans.Writer.Strict.WriterT w m a) instance GHC.Base.Functor m => GHC.Base.Functor (Control.Monad.Trans.Writer.Strict.WriterT w m) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Control.Monad.Trans.Writer.Strict.WriterT w f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Control.Monad.Trans.Writer.Strict.WriterT w f) instance (GHC.Base.Monoid w, GHC.Base.Applicative m) => GHC.Base.Applicative (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Base.Monoid w, GHC.Base.Alternative m) => GHC.Base.Alternative (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Base.Monoid w, GHC.Base.Monad m) => GHC.Base.Monad (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Base.Monoid w, GHC.Base.MonadPlus m) => GHC.Base.MonadPlus (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Base.Monoid w, Control.Monad.Fix.MonadFix m) => Control.Monad.Fix.MonadFix (Control.Monad.Trans.Writer.Strict.WriterT w m) instance GHC.Base.Monoid w => Control.Monad.Trans.Class.MonadTrans (Control.Monad.Trans.Writer.Strict.WriterT w) instance (GHC.Base.Monoid w, Control.Monad.IO.Class.MonadIO m) => Control.Monad.IO.Class.MonadIO (Control.Monad.Trans.Writer.Strict.WriterT w m) instance (GHC.Base.Monoid w, Control.Monad.Zip.MonadZip m) => Control.Monad.Zip.MonadZip (Control.Monad.Trans.Writer.Strict.WriterT w m) -- | Composition of functors. module Data.Functor.Compose -- | Right-to-left composition of functors. The composition of applicative -- functors is always applicative, but the composition of monads is not -- always a monad. newtype Compose f g a Compose :: f (g a) -> Compose f g a [getCompose] :: Compose f g a -> f (g a) instance GHC.Generics.Selector Data.Functor.Compose.S1_0_0Compose instance GHC.Generics.Constructor Data.Functor.Compose.C1_0Compose instance GHC.Generics.Datatype Data.Functor.Compose.D1Compose instance forall (k :: BOX) (k1 :: BOX) (f :: k -> *) (g :: k1 -> k) (a :: k1). GHC.Generics.Generic (Data.Functor.Compose.Compose f g a) instance (Data.Data.Data (f (g a)), Data.Typeable.Internal.Typeable f, Data.Typeable.Internal.Typeable g, Data.Typeable.Internal.Typeable a) => Data.Data.Data (Data.Functor.Compose.Compose f g a) instance GHC.Base.Functor f => GHC.Generics.Generic1 (Data.Functor.Compose.Compose f g) instance GHC.Generics.Datatype Data.Functor.Compose.MDCompose instance GHC.Generics.Constructor Data.Functor.Compose.MCCompose instance GHC.Generics.Selector Data.Functor.Compose.MSCompose instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 g) => Data.Functor.Classes.Eq1 (Data.Functor.Compose.Compose f g) instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 g) => Data.Functor.Classes.Ord1 (Data.Functor.Compose.Compose f g) instance (Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read1 g) => Data.Functor.Classes.Read1 (Data.Functor.Compose.Compose f g) instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 g) => Data.Functor.Classes.Show1 (Data.Functor.Compose.Compose f g) instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 g, GHC.Classes.Eq a) => GHC.Classes.Eq (Data.Functor.Compose.Compose f g a) instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 g, GHC.Classes.Ord a) => GHC.Classes.Ord (Data.Functor.Compose.Compose f g a) instance (Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read1 g, GHC.Read.Read a) => GHC.Read.Read (Data.Functor.Compose.Compose f g a) instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 g, GHC.Show.Show a) => GHC.Show.Show (Data.Functor.Compose.Compose f g a) instance (GHC.Base.Functor f, GHC.Base.Functor g) => GHC.Base.Functor (Data.Functor.Compose.Compose f g) instance (Data.Foldable.Foldable f, Data.Foldable.Foldable g) => Data.Foldable.Foldable (Data.Functor.Compose.Compose f g) instance (Data.Traversable.Traversable f, Data.Traversable.Traversable g) => Data.Traversable.Traversable (Data.Functor.Compose.Compose f g) instance (GHC.Base.Applicative f, GHC.Base.Applicative g) => GHC.Base.Applicative (Data.Functor.Compose.Compose f g) instance (GHC.Base.Alternative f, GHC.Base.Applicative g) => GHC.Base.Alternative (Data.Functor.Compose.Compose f g) -- | Products, lifted to functors. module Data.Functor.Product -- | Lifted product of functors. data Product f g a Pair :: (f a) -> (g a) -> Product f g a instance GHC.Generics.Constructor Data.Functor.Product.C1_0Product instance GHC.Generics.Datatype Data.Functor.Product.D1Product instance forall (k :: BOX) (f :: k -> *) (g :: k -> *) (a :: k). GHC.Generics.Generic (Data.Functor.Product.Product f g a) instance (Data.Data.Data (f a), Data.Data.Data (g a), Data.Typeable.Internal.Typeable f, Data.Typeable.Internal.Typeable g, Data.Typeable.Internal.Typeable a) => Data.Data.Data (Data.Functor.Product.Product f g a) instance GHC.Generics.Generic1 (Data.Functor.Product.Product f g) instance GHC.Generics.Datatype Data.Functor.Product.MDProduct instance GHC.Generics.Constructor Data.Functor.Product.MCPair instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 g) => Data.Functor.Classes.Eq1 (Data.Functor.Product.Product f g) instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 g) => Data.Functor.Classes.Ord1 (Data.Functor.Product.Product f g) instance (Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read1 g) => Data.Functor.Classes.Read1 (Data.Functor.Product.Product f g) instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 g) => Data.Functor.Classes.Show1 (Data.Functor.Product.Product f g) instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 g, GHC.Classes.Eq a) => GHC.Classes.Eq (Data.Functor.Product.Product f g a) instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 g, GHC.Classes.Ord a) => GHC.Classes.Ord (Data.Functor.Product.Product f g a) instance (Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read1 g, GHC.Read.Read a) => GHC.Read.Read (Data.Functor.Product.Product f g a) instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 g, GHC.Show.Show a) => GHC.Show.Show (Data.Functor.Product.Product f g a) instance (GHC.Base.Functor f, GHC.Base.Functor g) => GHC.Base.Functor (Data.Functor.Product.Product f g) instance (Data.Foldable.Foldable f, Data.Foldable.Foldable g) => Data.Foldable.Foldable (Data.Functor.Product.Product f g) instance (Data.Traversable.Traversable f, Data.Traversable.Traversable g) => Data.Traversable.Traversable (Data.Functor.Product.Product f g) instance (GHC.Base.Applicative f, GHC.Base.Applicative g) => GHC.Base.Applicative (Data.Functor.Product.Product f g) instance (GHC.Base.Alternative f, GHC.Base.Alternative g) => GHC.Base.Alternative (Data.Functor.Product.Product f g) instance (GHC.Base.Monad f, GHC.Base.Monad g) => GHC.Base.Monad (Data.Functor.Product.Product f g) instance (GHC.Base.MonadPlus f, GHC.Base.MonadPlus g) => GHC.Base.MonadPlus (Data.Functor.Product.Product f g) instance (Control.Monad.Fix.MonadFix f, Control.Monad.Fix.MonadFix g) => Control.Monad.Fix.MonadFix (Data.Functor.Product.Product f g) instance (Control.Monad.Zip.MonadZip f, Control.Monad.Zip.MonadZip g) => Control.Monad.Zip.MonadZip (Data.Functor.Product.Product f g) -- | Sums, lifted to functors. module Data.Functor.Sum -- | Lifted sum of functors. data Sum f g a InL :: (f a) -> Sum f g a InR :: (g a) -> Sum f g a instance GHC.Generics.Constructor Data.Functor.Sum.C1_1Sum instance GHC.Generics.Constructor Data.Functor.Sum.C1_0Sum instance GHC.Generics.Datatype Data.Functor.Sum.D1Sum instance forall (k :: BOX) (f :: k -> *) (g :: k -> *) (a :: k). GHC.Generics.Generic (Data.Functor.Sum.Sum f g a) instance (Data.Data.Data (f a), Data.Data.Data (g a), Data.Typeable.Internal.Typeable f, Data.Typeable.Internal.Typeable g, Data.Typeable.Internal.Typeable a) => Data.Data.Data (Data.Functor.Sum.Sum f g a) instance GHC.Generics.Generic1 (Data.Functor.Sum.Sum f g) instance GHC.Generics.Datatype Data.Functor.Sum.MDSum instance GHC.Generics.Constructor Data.Functor.Sum.MCInL instance GHC.Generics.Constructor Data.Functor.Sum.MCInR instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 g) => Data.Functor.Classes.Eq1 (Data.Functor.Sum.Sum f g) instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 g) => Data.Functor.Classes.Ord1 (Data.Functor.Sum.Sum f g) instance (Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read1 g) => Data.Functor.Classes.Read1 (Data.Functor.Sum.Sum f g) instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 g) => Data.Functor.Classes.Show1 (Data.Functor.Sum.Sum f g) instance (Data.Functor.Classes.Eq1 f, Data.Functor.Classes.Eq1 g, GHC.Classes.Eq a) => GHC.Classes.Eq (Data.Functor.Sum.Sum f g a) instance (Data.Functor.Classes.Ord1 f, Data.Functor.Classes.Ord1 g, GHC.Classes.Ord a) => GHC.Classes.Ord (Data.Functor.Sum.Sum f g a) instance (Data.Functor.Classes.Read1 f, Data.Functor.Classes.Read1 g, GHC.Read.Read a) => GHC.Read.Read (Data.Functor.Sum.Sum f g a) instance (Data.Functor.Classes.Show1 f, Data.Functor.Classes.Show1 g, GHC.Show.Show a) => GHC.Show.Show (Data.Functor.Sum.Sum f g a) instance (GHC.Base.Functor f, GHC.Base.Functor g) => GHC.Base.Functor (Data.Functor.Sum.Sum f g) instance (Data.Foldable.Foldable f, Data.Foldable.Foldable g) => Data.Foldable.Foldable (Data.Functor.Sum.Sum f g) instance (Data.Traversable.Traversable f, Data.Traversable.Traversable g) => Data.Traversable.Traversable (Data.Functor.Sum.Sum f g) -- | Making functors with an Applicative instance that performs -- actions in the reverse order. module Control.Applicative.Backwards -- | The same functor, but with an Applicative instance that -- performs actions in the reverse order. newtype Backwards f a Backwards :: f a -> Backwards f a [forwards] :: Backwards f a -> f a instance Data.Functor.Classes.Eq1 f => Data.Functor.Classes.Eq1 (Control.Applicative.Backwards.Backwards f) instance Data.Functor.Classes.Ord1 f => Data.Functor.Classes.Ord1 (Control.Applicative.Backwards.Backwards f) instance Data.Functor.Classes.Read1 f => Data.Functor.Classes.Read1 (Control.Applicative.Backwards.Backwards f) instance Data.Functor.Classes.Show1 f => Data.Functor.Classes.Show1 (Control.Applicative.Backwards.Backwards f) instance (Data.Functor.Classes.Eq1 f, GHC.Classes.Eq a) => GHC.Classes.Eq (Control.Applicative.Backwards.Backwards f a) instance (Data.Functor.Classes.Ord1 f, GHC.Classes.Ord a) => GHC.Classes.Ord (Control.Applicative.Backwards.Backwards f a) instance (Data.Functor.Classes.Read1 f, GHC.Read.Read a) => GHC.Read.Read (Control.Applicative.Backwards.Backwards f a) instance (Data.Functor.Classes.Show1 f, GHC.Show.Show a) => GHC.Show.Show (Control.Applicative.Backwards.Backwards f a) instance GHC.Base.Functor f => GHC.Base.Functor (Control.Applicative.Backwards.Backwards f) instance GHC.Base.Applicative f => GHC.Base.Applicative (Control.Applicative.Backwards.Backwards f) instance GHC.Base.Alternative f => GHC.Base.Alternative (Control.Applicative.Backwards.Backwards f) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Control.Applicative.Backwards.Backwards f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Control.Applicative.Backwards.Backwards f) -- | Making functors whose elements are notionally in the reverse order -- from the original functor. module Data.Functor.Reverse -- | The same functor, but with Foldable and Traversable -- instances that process the elements in the reverse order. newtype Reverse f a Reverse :: f a -> Reverse f a [getReverse] :: Reverse f a -> f a instance Data.Functor.Classes.Eq1 f => Data.Functor.Classes.Eq1 (Data.Functor.Reverse.Reverse f) instance Data.Functor.Classes.Ord1 f => Data.Functor.Classes.Ord1 (Data.Functor.Reverse.Reverse f) instance Data.Functor.Classes.Read1 f => Data.Functor.Classes.Read1 (Data.Functor.Reverse.Reverse f) instance Data.Functor.Classes.Show1 f => Data.Functor.Classes.Show1 (Data.Functor.Reverse.Reverse f) instance (Data.Functor.Classes.Eq1 f, GHC.Classes.Eq a) => GHC.Classes.Eq (Data.Functor.Reverse.Reverse f a) instance (Data.Functor.Classes.Ord1 f, GHC.Classes.Ord a) => GHC.Classes.Ord (Data.Functor.Reverse.Reverse f a) instance (Data.Functor.Classes.Read1 f, GHC.Read.Read a) => GHC.Read.Read (Data.Functor.Reverse.Reverse f a) instance (Data.Functor.Classes.Show1 f, GHC.Show.Show a) => GHC.Show.Show (Data.Functor.Reverse.Reverse f a) instance GHC.Base.Functor f => GHC.Base.Functor (Data.Functor.Reverse.Reverse f) instance GHC.Base.Applicative f => GHC.Base.Applicative (Data.Functor.Reverse.Reverse f) instance GHC.Base.Alternative f => GHC.Base.Alternative (Data.Functor.Reverse.Reverse f) instance Data.Foldable.Foldable f => Data.Foldable.Foldable (Data.Functor.Reverse.Reverse f) instance Data.Traversable.Traversable f => Data.Traversable.Traversable (Data.Functor.Reverse.Reverse f)