Documentation

Monads in which IO computations may be embedded. Any monad built by applying a sequence of monad transformers to the IO monad will be an instance of this class.

Instances should satisfy the following laws, which state that liftIO is a transformer of monads:

• liftIO . return = return

• liftIO (m >>= f) = liftIO m >>= (liftIO . f)

Build and returns a new instance of Chan.

Any instance of ArrowApply can be made into an instance of ArrowChoice by defining left = leftApp.

Postcomposition with a pure function (right-to-left variant).

Precomposition with a pure function (right-to-left variant).

Postcomposition with a pure function.

Precomposition with a pure function.

The identity arrow, which plays the role of return in arrow notation.

The basic arrow class.

Instances should satisfy the following laws:

• arr id = id

• arr (f >>> g) = arr f >>> arr g

• first (arr f) = arr (first f)

• first (f >>> g) = first f >>> first g

• first f >>> arr fst = arr fst >>> f

• first f >>> arr (id *** g) = arr (id *** g) >>> first f

• first (first f) >>> arr assoc = arr assoc >>> first f

where

assoc ((a,b),c) = (a,(b,c))

The other combinators have sensible default definitions, which may be overridden for efficiency.

Kleisli arrows of a monad.

A monoid on arrows.

Choice, for arrows that support it. This class underlies the if and case constructs in arrow notation.

Instances should satisfy the following laws:

• left (arr f) = arr (left f)

• left (f >>> g) = left f >>> left g

• f >>> arr Left = arr Left >>> left f

• left f >>> arr (id +++ g) = arr (id +++ g) >>> left f

• left (left f) >>> arr assocsum = arr assocsum >>> left f

where

assocsum (Left (Left x)) = Left x
assocsum (Left (Right y)) = Right (Left y)
assocsum (Right z) = Right (Right z)

The other combinators have sensible default definitions, which may be overridden for efficiency.

Some arrows allow application of arrow inputs to other inputs. Instances should satisfy the following laws:

• first (arr (\x -> arr (\y -> (x,y)))) >>> app = id

• first (arr (g >>>)) >>> app = second g >>> app

• first (arr (>>> h)) >>> app = app >>> h

Such arrows are equivalent to monads (see ArrowMonad).

The ArrowApply class is equivalent to Monad: any monad gives rise to a Kleisli arrow, and any instance of ArrowApply defines a monad.

The loop operator expresses computations in which an output value is fed back as input, although the computation occurs only once. It underlies the rec value recursion construct in arrow notation. loop should satisfy the following laws:

extension

loop (arr f) = arr (\ b -> fst (fix (\ (c,d) -> f (b,d))))

left tightening

loop (first h >>> f) = h >>> loop f

right tightening

loop (f >>> first h) = loop f >>> h

sliding

loop (f >>> arr (id *** k)) = loop (arr (id *** k) >>> f)

vanishing

loop (loop f) = loop (arr unassoc >>> f >>> arr assoc)

superposing

second (loop f) = loop (arr assoc >>> second f >>> arr unassoc)

where

assoc ((a,b),c) = (a,(b,c))
unassoc (a,(b,c)) = ((a,b),c)

Left-to-right composition

Right-to-left composition

An MSF without an ExceptT layer never throws an exception, and can thus have an arbitrary exception type.

If no exception can occur, the MSF can be executed without the ExceptT layer.

Immediately throw the current input as an exception.

Escape an ExceptT layer by outputting the exception whenever it occurs. If an exception occurs, the current MSF continuation is tested again on the next input.

The empty type. As an exception type, it encodes "no exception possible".

Outputs every input sample, with a given message prefix, when a condition is met, and waits for some input / enter to continue.

Outputs every input sample, with a given message prefix, using an auxiliary printing function, when a condition is met.

Outputs every input sample, with a given message prefix, using an auxiliary printing function.

Outputs every input sample, with a given message prefix.

Generate outputs using a step-wise generation function and an initial value. Version of unfold in which the output and the new accumulator are the same. Should be equal to f a -> unfold (f >>> dup) a.

Generate outputs using a step-wise generation function and an initial value.

Applies a function to the input and an accumulator, outputing the accumulator. Equal to f s0 -> feedback s0 $ arr (uncurry f >>> dup).

Accumulate the inputs, starting from an initial monoid value.

Accumulate the inputs, starting from mempty.

Sums the inputs, starting from an initial vector.

Sums the inputs, starting from zero.

Count the number of simulation steps. Produces 1, 2, 3,...

Buffers and returns the elements in FIFO order, returning Nothing whenever the buffer is empty.

Preprends a fixed output to an MSF, shifting the output.

Preprends a fixed output to an MSF. The first input is completely ignored.

Produces an additional side effect and passes the input unchanged.

Applies a function to produce an additional side effect and passes the input unchanged.

Apply an MSF to every input. Freezes temporarily if the input is Nothing, and continues as soon as a Just is received.

Apply an MSF to every input.

Lifts a computation into a Stream.

Pre-inserts an input sample.

A stream is an MSF that produces outputs ignoring the input. It can obtain the values from a monadic context.

A stream is an MSF that produces outputs producing no output. It can consume the values with side effects.

R-modules. A module v over a ring Groundring v is an abelian group with a linear multiplication. The hat ^ denotes the side of an operation on which the vector stands, i.e. a *^ v for v a vector.

A minimal definition should include the type Groundring and the implementations of zeroVector, ^+^, and one of *^ or ^*.

The following laws must be satisfied:

• v1 ^+^ v2 == v2 ^+^ v1

• a *^ zeroVector == zeroVector

• @a *^ (v1 ^+^ v2) == a *^ v1 ^+^ a*^ v2

• a *^ v == v ^* a

• negateVector v == (-1) *^ v

• v1 ^-^ v2 == v1 ^+^ negateVector v2

A vector space is a module over a field, i.e. a commutative ring with inverses.

It needs to satisfy the axiom v ^ a == (1a) *^ v, which is the default implementation.

The ground ring of a vector space is required to be commutative and to possess inverses. It is then called the "ground field". Commutativity amounts to the law a * b = b * a, and the existence of inverses is given by the requirement of the Fractional type class.

An inner product space is a module with an inner product, i.e. a map dot satisfying

• v1 dot v2 == v2 dot v1

• (v1 ^+^ v2) dot v3 == v1 dot v3 ^+^ v2 dot v3

• (a *^ v1) dot v2 == a *^ v1 dot v2

A normed space is a module with a norm, i.e. a function norm satisfying

• norm (a ^* v) = a ^* norm v

• norm (v1 ^+^ v2) <= norm v1 ^+^ norm v2 (the "triangle inequality")

A typical example is sqrt (v dot v), for an inner product space.

Run an MSF indefinitely passing a unit-carrying input stream.

Apply a monadic stream function to a list.

Because the result is in a monad, it may be necessary to traverse the whole list to evaluate the value in the results to WHNF. For example, if the monad is the maybe monad, this may not produce anything if the MSF produces Nothing at any point, so the output stream cannot consumed progressively.

To explore the output progressively, use liftMSF and '(>>>)'', together with some action that consumes/actuates on the output.

This is called runSF in Liu, Cheng, Hudak, "Causal Commutative Arrows and Their Optimization"

Well-formed looped connection of an output component as a future input.

Switching applies one MSF until it produces a Just output, and then "turns on" a continuation and runs it.

A more advanced and comfortable approach to switching is given by Exceptions in Except

See iPre.

Delay a signal by one sample.

Lifting purer monadic actions (in an arbitrary way)

Lift innermost monadic actions in a monad stacks (generalisation of liftIO).

Lift inner monadic actions in monad stacks.

Monadic lifting from one monad into another

Apply a monadic transformation to every element of the input stream.

Generalisation of arr from Arrow to monadic functions.

Stepwise, side-effectful MSFs without implicit knowledge of time.

MSFs should be applied to streams or executed indefinitely or until they terminate. See reactimate and reactimateB for details. In general, calling the value constructor MSF or the function unMSF is discouraged.

Constructor for computations in the exception monad. (The inverse of runExcept).

Signal an exception value e.

• runExceptT (throwE e) = return (Left e)

• throwE e >>= m = throwE e

Handle an exception.

• catchE h (lift m) = lift m

• catchE h (throwE e) = h e

Transform any exceptions thrown by the computation using the given function.

Map the unwrapped computation using the given function.

• runExceptT (mapExceptT f m) = f (runExceptT m)

The inverse of ExceptT.

Transform any exceptions thrown by the computation using the given function (a specialization of withExceptT).

Map the unwrapped computation using the given function.

• runExcept (mapExcept f m) = f (runExcept m)

Extractor for computations in the exception monad. (The inverse of except).

The parameterizable exception monad.

Computations are either exceptions or normal values.

The return function returns a normal value, while >>= exits on the first exception. For a variant that continues after an error and collects all the errors, see Errors.

A monad transformer that adds exceptions to other monads.

ExceptT constructs a monad parameterized over two things:

• e - The exception type.
• m - The inner monad.

The return function yields a computation that produces the given value, while >>= sequences two subcomputations, exiting on the first exception.

This is the simplest representation of UTC. It consists of the day number, and a time offset from midnight. Note that if a day has a leap second added to it, it will have 86401 seconds.

Lift a pass operation to the new monad.

Lift a listen operation to the new monad.

Lift a callCC operation to the new monad.

In a composite running clock, duplicate the tick of one subclock.

Any Num can be wrapped to form a TimeDomain.

A time domain is an affine space representing a notion of time, such as real time, simulated time, steps, or a completely different notion.

Lift a clock type into MonadIO.

Lift a clock type into a monad transformer.

Applying a monad morphism yields a new clock.

Instead of a mere function as morphism of time domains, we can transform one time domain into the other with a monadic stream function.

Instead of a mere function as morphism of time domains, we can transform one time domain into the other with an effectful morphism.

Applying a morphism of time domains yields a new clock.

Like RescalingS, but allows for an initialisation of the rescaling morphism, together with the initial time.

An effectful, stateful morphism of time domains is an MSF that uses side effects to rescale a point in one time domain into another one.

An effectful morphism of time domains is a Kleisli arrow. It can use a side effect to rescale a point in one time domain into another one.

A pure morphism of time domains is just a function.

An annotated, rich time stamp.

Since we want to leverage Haskell's type system to annotate signal networks by their clocks, each clock must be an own type, cl. Different values of the same clock type should tick at the same speed, and only differ in implementation details. Often, clocks are singletons.

When initialising a clock, the initial time is measured (typically by means of a side effect), and a running clock is returned.

A clock creates a stream of time stamps and additional information, possibly together with side effects in a monad m that cause the environment to wait until the specified time is reached.

A utility that changes the tag of a TimeInfo.

Given a clock value and an initial time, generate a stream of time stamps.

Convert an effectful morphism of time domains into a stateful one with initialisation. Think of its type as RescalingM m cl time -> RescalingSInit m cl time tag, although this type is ambiguous.

A RescaledClock is trivially a RescaledClockM.

A RescaledClockM is trivially a RescaledClockS.

A RescaledClock is trivially a RescaledClockS.

Lift a clock value into a monad transformer.

Lift a clock value into MonadIO.

An inclusion of a clock into a tree of parallel compositions of clocks.

A tree representing possible last times to which the constituents of a clock may have ticked.

The clock that represents the rate at which data leaves the system.

The clock that represents the rate at which data enters the system.

Abbrevation synonym.

Two clocks can be combined with a schedule as a clock for an asynchronous parallel composition of signal networks.