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 |

Arrow transformer lifting an arrow to streams.

- newtype StreamArrow a b c = StreamArrow (a (Stream b) (Stream 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

# Documentation

newtype StreamArrow a b c Source #

StreamArrow (a (Stream b) (Stream c)) |

Arrow a => ArrowTransformer StreamArrow a Source # | |

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

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

Arrow a => Arrow (StreamArrow a) Source # | |

ArrowZero a => ArrowZero (StreamArrow a) Source # | |

ArrowPlus a => ArrowPlus (StreamArrow a) Source # | |

Arrow a => ArrowChoice (StreamArrow a) Source # | |

ArrowLoop a => ArrowLoop (StreamArrow a) Source # | |

ArrowLoop a => ArrowCircuit (StreamArrow a) Source # | |

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

Category * a => Category * (StreamArrow a) Source # | |

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

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

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

ArrowPlus a => Semigroup (StreamArrow a b c) Source # | |

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

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

Encapsulate a local state.

class (ArrowCircuit a, Arrow a') => ArrowAddStream a a' | a -> a' where Source #

Adding a `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 `lift`

method of the `ArrowTransformer`

class,
or remove a state transformer from the top of the stack using the
`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 `lift`

and
`runStream`

respectively.
Instances are lifted through other transformers with

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

liftStream :: a' e b -> a e b Source #

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

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

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