# effect-stack: Reducing the pain of transformer stacks with duplicated effects

**This is a package candidate release!** Here you can preview how this package release will appear once published to the main package index (which can be accomplished via the 'maintain' link below). Please note that once a package has been published to the main package index it cannot be undone! Please consult the package uploading documentation for more information.

When using monad transformer stacks, it is common to want
to mix effects from various layers of the stack within a
single block of code. The `lift`

operation can be used to
convert an action that uses effects at some deep layer of
the stack into one that works in the full stack. It
quickly becomes tedious to include exactly the right
number of calls to `lift`

each time they are needed; and
makes the code more fragile when the transformer stack is
changed (e.g. to include a new effect).

The `mtl`

package provides a convenient way to point to a
particular layer of the stack, under the assumption that
there is exactly one "kind" of each interesting effect.
(For example, one can only have one type of state, one
type of environment to read from, and so forth.) However,
if one wishes to have to copies of a single kind of
effect, there is no convenient, generic way to choose
anything other than the one that appears topmost in the
stack. For example, for a stack that contains two
`StateT`

s in it, one can write code that accesses the
outermost state using a type like

MonadState outer m => m ()

but there is no polymorphic way to reach the inner
`StateT`

's state. One is back to writing fragile code that
depends on exactly which transformer stack was chosen.

This package provides a way to make such choices
generically: it introduces a separate stack for each kind
of effect, and provides an operation for popping one layer
of a given effect's stack. Continuing the `StateT`

example, one could write

MonadState outer m => m ()

as before for the outermost state, or

(StateStack m, MonadState inner (PopState m)) => m ()

to access the state from underneath the outermost
`StateT`

, no matter how deep it is.

## Properties

Versions | 0.1.0.0, 0.1.0.0, 0.1.0.1, 0.2, 0.2.1, 0.3 |
---|---|

Change log | ChangeLog.md |

Dependencies | base (==4.12.*), mtl, transformers (==0.5.*) [details] |

License | BSD-3-Clause |

Author | Daniel Wagner |

Maintainer | me@dmwit.com |

Category | Control |

Source repo | head: git clone https://github.com/dmwit/effect-stack |

Uploaded | by DanielWagner at 2019-07-05T01:08:20Z |

## Modules

*Control**Monad**Stack*- Control.Monad.Stack.Accum
- Control.Monad.Stack.Cont
- Control.Monad.Stack.Except
- Control.Monad.Stack.Fail
- Control.Monad.Stack.Reader
- Control.Monad.Stack.Select
- Control.Monad.Stack.State
- Control.Monad.Stack.Writer

## Downloads

- effect-stack-0.1.0.0.tar.gz [browse] (Cabal source package)
- Package description (as included in the package)

#### Maintainer's Corner

For package maintainers and hackage trustees