aivika-4.5: A multi-method simulation library

CopyrightCopyright (c) 2009-2016, David Sorokin <>
MaintainerDavid Sorokin <>
Safe HaskellNone




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.


Net Arrow

newtype Net a b Source #

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





Arrow Net Source # 


arr :: (b -> c) -> Net b c #

first :: Net b c -> Net (b, d) (c, d) #

second :: Net b c -> Net (d, b) (d, c) #

(***) :: Net b c -> Net b' c' -> Net (b, b') (c, c') #

(&&&) :: Net b c -> Net b c' -> Net b (c, c') #

ArrowChoice Net Source # 


left :: Net b c -> Net (Either b d) (Either c d) #

right :: Net b c -> Net (Either d b) (Either d c) #

(+++) :: Net b c -> Net b' c' -> Net (Either b b') (Either c c') #

(|||) :: Net b d -> Net c d -> Net (Either b c) d #

Category * Net Source # 


id :: cat a a #

(.) :: cat b c -> cat a b -> cat a c #

iterateNet :: Net a a -> a -> Process () Source #

Iterate infinitely using the specified initial value.

iterateNetMaybe :: Net a (Maybe a) -> a -> Process () Source #

Iterate the net using the specified initial value until Nothing is returned within the Net computation.

iterateNetEither :: Net a (Either b a) -> a -> Process b Source #

Iterate the net using the specified initial value until the Left result is returned within the Net computation.

Net Primitives

emptyNet :: Net a b Source #

A net that never finishes its work.

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

Accumulator that outputs a value determined by the supplied function.

withinNet :: Process () -> Net a a Source #

Involve the computation with side effect when processing the input.

Specifying Identifier

netUsingId :: ProcessId -> Net a b -> Net 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 :: Net a (Arrival a) Source #

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

Delaying Net

delayNet :: a -> Net a a Source #

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

Interchanging Nets with Processors

netProcessor :: Net a b -> Processor a b Source #

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

processorNet :: Processor a b -> Net a b Source #

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


traceNet Source #


:: Maybe String

the request message

-> Maybe String

the response message

-> Net a b

a net

-> Net a b 

Show the debug messages with the current simulation time.