FRP.Rhine.SN

Asynchronous signal networks are combinations of clocked signal functions (ClSFs) and matching ResamplingBuffers, all satisfying the appropriate clock type constraints.

This module defines the SN type, combinators are found in a submodule.

Documentation

data SN m cl a b where

An SN is a side-effectful asynchronous signal network, where input, data processing (including side effects) and output need not happen at the same time.

The type parameters are:

• m: The monad in which side effects take place.
• cl: The clock of the whole signal network. It may be sequentially or parallely composed from other clocks.
• a: The input type. Input arrives at the rate In cl.
• b: The output type. Output arrives at the rate Out cl.

Constructors

Synchronous :: (cl ~ In cl, cl ~ Out cl) => ClSF m cl a b -> SN m cl a b

A synchronous monadic stream function is the basic building block. For such an SN, data enters and leaves the system at the same rate as it is processed.

Sequential :: (Clock m clab, Clock m clcd, Clock m (Out clab), Clock m (Out clcd), Clock m (In clab), Clock m (In clcd), GetClockProxy clab, GetClockProxy clcd, Time clab ~ Time clcd, Time clab ~ Time (Out clab), Time clcd ~ Time (In clcd)) => SN m clab a b -> ResamplingBuffer m (Out clab) (In clcd) b c -> SN m clcd c d -> SN m (SequentialClock m clab clcd) a d

Two SNs may be sequentially composed if there is a matching ResamplingBuffer between them.

Parallel :: (Clock m cl1, Clock m cl2, Clock m (Out cl1), Clock m (Out cl2), GetClockProxy cl1, GetClockProxy cl2, Time cl1 ~ Time (Out cl1), Time cl2 ~ Time (Out cl2), Time cl1 ~ Time cl2, Time cl1 ~ Time (In cl1), Time cl2 ~ Time (In cl2)) => SN m cl1 a b -> SN m cl2 a b -> SN m (ParallelClock m cl1 cl2) a b

Two SNs with the same input and output data may be parallely composed.

FirstResampling :: (Clock m (In cl), Clock m (Out cl), Time cl ~ Time (Out cl), Time cl ~ Time (In cl)) => SN m cl a b -> ResamplingBuffer m (In cl) (Out cl) c d -> SN m cl (a, c) (b, d)

Bypass the signal network by forwarding data in parallel through a ResamplingBuffer.

Postcompose :: (Clock m (Out cl), Time cl ~ Time (Out cl)) => SN m cl a b -> ClSF m (Out cl) b c -> SN m cl a c

A ClSF can always be postcomposed onto an SN if the clocks match on the output.

Precompose :: (Clock m (In cl), Time cl ~ Time (In cl)) => ClSF m (In cl) a b -> SN m cl b c -> SN m cl a c

A ClSF can always be precomposed onto an SN if the clocks match on the input.

Feedback :: (Clock m (In cl), Clock m (Out cl), Time (In cl) ~ Time cl, Time (Out cl) ~ Time cl) => ResBuf m (Out cl) (In cl) d c -> SN m cl (a, c) (b, d) -> SN m cl a b

Data can be looped back to the beginning of an SN, but it must be resampled since the Out and In clocks are generally different.

Instances

GetClockProxy cl => ToClockProxy (SN m cl a b)

Defined in FRP.Rhine.SN

Associated Types

type Cl (SN m cl a b)

Methods

toClockProxy :: SN m cl a b -> ClockProxy (Cl (SN m cl a b))

type Cl (SN m cl a b)

Defined in FRP.Rhine.SN

type Cl (SN m cl a b) = cl