aivika-transformers-2.0: Transformers for the Aivika simulation library

CopyrightCopyright (c) 2009-2014, David Sorokin <david.sorokin@gmail.com>
LicenseBSD3
MaintainerDavid Sorokin <david.sorokin@gmail.com>
Stabilityexperimental
Safe HaskellNone
LanguageHaskell2010

Simulation.Aivika.Trans.Net

Contents

Description

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.

Synopsis

Net Arrow

newtype Net m a b Source

Represents the net as an automaton working within the Process computation.

Constructors

Net 

Fields

runNet :: a -> Process m (b, Net m a b)

Run the net.

Instances

MonadComp m => Category * (Net m) 
MonadComp m => Arrow (Net m) 
MonadComp m => ArrowChoice (Net m) 

Net Primitives

emptyNet :: MonadComp m => Net m a b Source

A net that never finishes its work.

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).