Portability | non-portable (multi-parameter type classes) |
---|---|

Stability | experimental |

Maintainer | ross@soi.city.ac.uk |

Safe Haskell | None |

An arrow transformer that adds a modifiable state,
based of section 9 of *Generalising Monads to Arrows*, by John Hughes,
*Science of Computer Programming* 37:67-111, May 2000.

- newtype StateArrow s a b c = StateArrow (a (b, s) (c, s))
- runState :: Arrow a => StateArrow s a e b -> a (e, s) (b, s)
- class (ArrowState s a, Arrow a') => ArrowAddState s a a' | a -> a' where

# Documentation

newtype StateArrow s a b c Source

An arrow type that augments an existing arrow with a modifiable
state. The `ArrowState`

class contains the operations on this state.

StateArrow (a (b, s) (c, s)) |

runState :: Arrow a => StateArrow s a e b -> a (e, s) (b, s)Source

Encapsulation of a state-using computation, exposing the initial and final states.

Typical usage in arrow notation:

proc p -> do ... (result, final_state) <- (|runState cmd|) init_state

class (ArrowState s a, Arrow a') => ArrowAddState s a a' | a -> a' whereSource

Adding a `StateArrow`

to an
arrow type, but not necessarily as the outer arrow transformer.

Typically a composite arrow type is built by applying a series
of arrow transformer to a base arrow (usually either a function
arrow or a `Kleisli`

arrow. One can add a transformer to the
top of this stack using the `lift`

method of the `ArrowTransformer`

class,
or remove a state transformer from the top of the stack using the
`runState`

encapsulation operator.
The methods of this class add and remove state transformers anywhere
in the stack. In the instance

instance Arrow a => ArrowAddState s (ArrowState s a) a

they are equivalent to `lift`

and
`runState`

respectively.
Instances are lifted through other transformers with

instance ArrowAddState s a a' => ArrowAddState s (FooArrow a) (FooArrow a')

liftState :: a' e b -> a e bSource

Lift a computation from an arrow to one with an added state.

Typical usage in arrow notation:

proc p -> ... (|liftState cmd|)

elimState :: a e b -> a' (e, s) (b, s)Source

Elimination of a state transformer from a computation, exposing the initial and final states.

Typical usage in arrow notation:

proc p -> do ... (result, final_state) <- (|elimState cmd|) init_state

(ArrowState r (Automaton a), Arrow (Automaton a'), ArrowAddState r a a') => ArrowAddState r (Automaton a) (Automaton a') | |

(ArrowState s (StateArrow s a), Arrow a) => ArrowAddState s (StateArrow s a) a | |

(ArrowState s (ErrorArrow ex a), Arrow (ErrorArrow ex a'), ArrowAddState s a a', ArrowChoice a, ArrowChoice a') => ArrowAddState s (ErrorArrow ex a) (ErrorArrow ex a') | |

(ArrowState s (StaticArrow f a), Arrow (StaticArrow f a'), ArrowAddState s a a', Applicative f) => ArrowAddState s (StaticArrow f a) (StaticArrow f a') | |

(ArrowState s (WriterArrow w a), Arrow (WriterArrow w a'), ArrowAddState s a a', Monoid w) => ArrowAddState s (WriterArrow w a) (WriterArrow w a') | |

(ArrowState s (ReaderArrow r a), Arrow (ReaderArrow r a'), ArrowAddState s a a') => ArrowAddState s (ReaderArrow r a) (ReaderArrow r a') |