Copyright | Copyright (c) 2009-2014, David Sorokin <david.sorokin@gmail.com> |
---|---|

License | BSD3 |

Maintainer | David Sorokin <david.sorokin@gmail.com> |

Stability | experimental |

Safe Haskell | None |

Language | Haskell2010 |

Tested with: GHC 7.8.3

The module defines a `Net`

arrow that can be applied to modeling the queue networks
like the `Processor`

arrow from another module. Only the former has a more efficient
implementation of the `Arrow`

interface than the latter, although at the cost of
some decreasing in generality.

While the `Processor`

type is just a function that transforms the input `Stream`

into another,
the `Net`

type is actually an automaton that has an implementation very similar to that one
which the `Circuit`

type has, only the computations occur in the `Process`

monad. But unlike
the `Circuit`

type, the `Net`

type doesn't allow declaring recursive definitions, being based on
continuations.

In a nutshell, the `Net`

type is an interchangeable alternative to the `Processor`

type
with its weaknesses and strengths. The `Net`

arrow is useful for constructing computations
with help of the proc-notation to be transformed then to the `Processor`

computations that
are more general in nature and more easy-to-use but which computations created with help of
the proc-notation are not so efficient.

- newtype Net m a b = Net {}
- emptyNet :: MonadComp m => Net m a b
- arrNet :: MonadComp m => (a -> Process m b) -> Net m a b
- accumNet :: MonadComp m => (acc -> a -> Process m (acc, b)) -> acc -> Net m a b
- netUsingId :: MonadComp m => ProcessId m -> Net m a b -> Net m a b
- arrivalNet :: MonadComp m => Net m a (Arrival a)
- delayNet :: MonadComp m => a -> Net m a a
- netProcessor :: MonadComp m => Net m a b -> Processor m a b
- processorNet :: MonadComp m => Processor m a b -> Net m a b

# Net Arrow

Represents the net as an automaton working within the `Process`

computation.

# Net Primitives

arrNet :: MonadComp m => (a -> Process m b) -> Net m a b Source

Create a simple net by the specified handling function that runs the discontinuous process for each input value to get an output.

accumNet :: MonadComp m => (acc -> a -> Process m (acc, b)) -> acc -> Net m a b Source

Accumulator that outputs a value determined by the supplied function.

# Specifying Identifier

netUsingId :: MonadComp m => ProcessId m -> Net m a b -> Net m a b Source

Create a net that will use the specified process identifier.
It can be useful to refer to the underlying `Process`

computation which
can be passivated, interrupted, canceled and so on. See also the
`processUsingId`

function for more details.

# Arrival Net

arrivalNet :: MonadComp m => Net m a (Arrival a) Source

A net that adds the information about the time points at which the values were received.

# Delaying Net

delayNet :: MonadComp m => a -> Net m a a Source

Delay the input by one step using the specified initial value.

# Interchanging Nets with Processors

netProcessor :: MonadComp m => Net m a b -> Processor m a b Source

Transform the net to an equivalent processor (a rather cheap transformation).

processorNet :: MonadComp m => Processor m a b -> Net m a b Source

Transform the processor to a similar net (a more costly transformation).