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

Stability | experimental |

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

Arrow transformer lifting an arrow to streams.

- data StreamArrow a b c
- runStream :: ArrowLoop a => StreamArrow a (e, b) c -> a (e, Stream b) (Stream c)
- type StreamMap = StreamArrow (->)
- type StreamMapST s = StreamArrow (Kleisli (ST s))
- runStreamST :: (forall s. StreamMapST s e c) -> StreamMap e c
- class (ArrowCircuit a, Arrow a') => ArrowAddStream a a' | a -> a' where
- liftStream :: a' e b -> a e b
- elimStream :: a (e, b) c -> a' (e, Stream b) (Stream c)

# Documentation

data StreamArrow a b c Source

Arrow a => ArrowTransformer StreamArrow a | |

ArrowWriter w a => ArrowWriter w (StreamArrow a) | |

ArrowState s a => ArrowState s (StreamArrow a) | |

Arrow a => Arrow (StreamArrow a) | |

ArrowZero a => ArrowZero (StreamArrow a) | |

ArrowPlus a => ArrowPlus (StreamArrow a) | |

Arrow a => ArrowChoice (StreamArrow a) | |

ArrowLoop a => ArrowLoop (StreamArrow a) | |

Category a => Category (StreamArrow a) | |

ArrowLoop a => ArrowCircuit (StreamArrow a) | |

ArrowLoop a => ArrowAddStream (StreamArrow a) a | |

Arrow a => Functor (StreamArrow a b) | |

Arrow a => Applicative (StreamArrow a b) | |

ArrowPlus a => Alternative (StreamArrow a b) | |

ArrowPlus a => Monoid (StreamArrow a b c) |

runStream :: ArrowLoop a => StreamArrow a (e, b) c -> a (e, Stream b) (Stream c)Source

Run a stream processor on a stream of inputs, obtaining a stream of outputs.

Typical usage in arrow notation:

proc p -> do ... ys <- (|runStream (\x -> ...)|) xs

Here `xs`

refers to the input stream and `x`

to individual
elements of that stream. `ys`

is bound to the output stream.

type StreamMap = StreamArrow (->)Source

Mappings of streams

type StreamMapST s = StreamArrow (Kleisli (ST s))Source

In-place state updates.

*Note*: this is an arrow type, and `lift`

can be used to promote arrows
from

: the resulting arrow updates the state for
each stream element in turn, and as long as the final state in not
required all is well. However, `Kleisli`

(`ST`

s)`lift`

does not preserve composition,
because this monad isn't commutative. In particular, a composition
of `lift`

s of state transformers will not work, as the second will
require the final state of the first.

runStreamST :: (forall s. StreamMapST s e c) -> StreamMap e cSource

Encapsulate a local state.

class (ArrowCircuit a, Arrow a') => ArrowAddStream a a' | a -> a' whereSource

Adding a `Control.Arrow.Transformer.Stream.StreamArrow`

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 `Control.Arrow.Transformer.lift`

method of the `Control.Arrow.Transformer.ArrowTransformer`

class,
or remove a state transformer from the top of the stack using the
`Control.Arrow.Transformer.Stream.runStream`

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

instance Arrow a => ArrowAddStream (ArrowStream a) a

they are equivalent to `Control.Arrow.Transformer.lift`

and
`Control.Arrow.Transformer.Stream.runStream`

respectively.
Instances are lifted through other transformers with

instance ArrowAddStream a a' => ArrowAddStream (FooArrow a) (FooArrow a')

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

Lift a computation from an arrow to a stream processing one.

Typical usage in arrow notation:

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

elimStream :: a (e, b) c -> a' (e, Stream b) (Stream c)Source

Run a stream processor on a stream of inputs, obtaining a stream of outputs.

Typical usage in arrow notation:

proc p -> do ... ys <- (|elimStream (\x -> ...)|) xs

Here `xs`

refers to the input stream and `x`

to individual
elements of that stream. `ys`

is bound to the output stream.

(ArrowLoop a, ArrowApply a) => ArrowAddStream (Automaton a) a | |

ArrowLoop a => ArrowAddStream (StreamArrow a) a | |

(ArrowAddStream a a', Applicative f) => ArrowAddStream (StaticArrow f a) (StaticArrow f a') |