Copyright | (c) Ross Paterson 2003 |
---|---|

License | BSD-style (see the LICENSE file in the distribution) |

Maintainer | R.Paterson@city.ac.uk |

Stability | experimental |

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

Safe Haskell | Safe |

Language | Haskell98 |

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' where Source #

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 b Source #

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

ArrowAddState r a a' => ArrowAddState r (Automaton a) (Automaton a') Source # | |

Arrow a => ArrowAddState s (StateArrow s a) a Source # | |

(ArrowAddState s a a', ArrowChoice a, ArrowChoice a') => ArrowAddState s (ErrorArrow ex a) (ErrorArrow ex a') Source # | |

ArrowAddState s a a' => ArrowAddState s (ReaderArrow r a) (ReaderArrow r a') Source # | |

(ArrowAddState s a a', Applicative f) => ArrowAddState s (StaticArrow f a) (StaticArrow f a') Source # | |

(ArrowAddState s a a', Monoid w) => ArrowAddState s (WriterArrow w a) (WriterArrow w a') Source # | |