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

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 StateTs 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.

• 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