Copyright | Copyright (c) 2009-2016 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 8.0.1

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 {}
- iterateNet :: MonadDES m => Net m a a -> a -> Process m ()
- iterateNetMaybe :: MonadDES m => Net m a (Maybe a) -> a -> Process m ()
- iterateNetEither :: MonadDES m => Net m a (Either b a) -> a -> Process m b
- emptyNet :: MonadDES m => Net m a b
- arrNet :: MonadDES m => (a -> Process m b) -> Net m a b
- accumNet :: MonadDES m => (acc -> a -> Process m (acc, b)) -> acc -> Net m a b
- withinNet :: MonadDES m => Process m () -> Net m a a
- netUsingId :: MonadDES m => ProcessId m -> Net m a b -> Net m a b
- arrivalNet :: MonadDES m => Net m a (Arrival a)
- delayNet :: MonadDES m => a -> Net m a a
- netProcessor :: MonadDES m => Net m a b -> Processor m a b
- processorNet :: MonadDES m => Processor m a b -> Net m a b
- traceNet :: MonadDES m => Maybe String -> Maybe String -> Net m a b -> Net m a b

# Net Arrow

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

computation.

iterateNet :: MonadDES m => Net m a a -> a -> Process m () Source #

Iterate infinitely using the specified initial value.

# Net Primitives

arrNet :: MonadDES 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 :: MonadDES m => (acc -> a -> Process m (acc, b)) -> acc -> Net m a b Source #

Accumulator that outputs a value determined by the supplied function.

withinNet :: MonadDES m => Process m () -> Net m a a Source #

Involve the computation with side effect when processing the input.

# Specifying Identifier

netUsingId :: MonadDES 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 :: MonadDES 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 :: MonadDES m => a -> Net m a a Source #

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

# Interchanging Nets with Processors

netProcessor :: MonadDES m => Net m a b -> Processor m a b Source #

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

processorNet :: MonadDES m => Processor m a b -> Net m a b Source #

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