The reactor-like DE event, defined exactly like its DE predecessor, and identifying a discrete event signal. The type of the tag system needs to satisfy all of the three properties, as suggested by the type constraints imposed on it:

• it needs to be a numerical type and every representable number needs to have an additive inverse.
• it needs to be unambiguously comparable (defines a total order).
• it needs to unambiguously define an equality operation.

Due to these properties not all numerical types can represent DE tags. A typical example of inappropriate representation is Float.

Convenience alias for a DE signal, where tags are represented using our exported TimeStamp type.

Type synonym for a base DE signal as a stream of DE events, where the type of tags has not been determined yet. In designs, it is advised to define a type alias for signals, using an appropriate numerical type for tags, e.g.

import ForSyDe.Atom.MoC.DE.React hiding (Signal) -- hide provided alias, to use your own

type Signal a = SignalBase Int a

Wraps a (tuple of) pair(s) (tag, value) into the equivalent unit signal(s). A unit signal is a signal with one event with the period tag carrying value, starting at tag 0.

Helpers: unit and unit[2-4].

Creates a signal with an instant event at time 0.

Takes the first part of the signal util a given timestamp. The last event of the resulting signal is at the given timestamp and carries the previous value. This utility is useful when plotting a signal, to specify the interval of plotting.

Transforms a list of tuples (tag, value) into a RE signal. Checks if it is well-formed.

Checks if a signal is well-formed or not, according to the RE MoC interpretation in ForSyDe-Atom.

Reads a signal from a string and checks if it is well-formed. Like with the read function from Prelude, you must specify the type of the signal.

>>> readSignal "{ 1@0, 2@2, 3@5, 4@7, 5@10 }" :: Signal Int
{1@0s,2@2s,3@5s,4@7s,5@10s}
>>> readSignal "{ 1@1, 2@2, 3@5, 4@7, 5@10 }" :: Signal Int
{1@1s,2@2s,3@5s,4@7s,5@10s}

Incorrect usage (not covered by doctest):

λ> readSignal "{ 1@0, 2@2, 3@5, 4@10, 5@7 }" :: Signal Int
{1@0s,2@2s,3@5s*** Exception: [MoC.RE] malformed signal

The delay process "delays" a signal with one event, (see the delay pattern). Any delayed signal starts from global 0.

>>> let s = readSignal "{1@2, 2@3, 3@6, 4@8, 5@9}" :: Signal Int
>>> delay 3 0 s
{0@0s,1@5s,2@6s,3@9s,4@11s,5@12s}

Similar to the previous, but this is the raw instantiation of the delay pattern from ForSyDe.Atom.MoC. It "borrows" the first event from one signal and appends it at the head of another signal.

>>> let s1 = readSignal "{1@(-1), 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> let s2 = readSignal "{3@2, 4@4, 5@5, 6@8, 7@9}" :: Signal Int
>>> delay' s1 s2
{1@-1s,3@5s,4@7s,5@8s,6@11s,7@12s}

This process "delays" only the tags of a signal. The "usafe" prefix is a warning that it does not express prefix behavior (->-), which means that in a feedback loop it will cause deadlock.

>>> let s = readSignal "{1@(-1), 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> unsafeDelay 3 s
{1@2s,2@5s,3@9s,4@11s,5@12s}

comb processes map a trigger-aware combinational function on signals and take care of synchronization between input signals.

Constructors: comb[1-4][1-4].

>>> let s1 = instant 1
>>> let s2 = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: RE.Signal Int
>>> comb11 (map (+1)) s2
{2@0s,3@2s,4@6s,5@8s,6@9s}
>>> let {f [a] [b] = ([a+b],[a-b]); f [a] []  = ([a],[a]); f [] [b]  = ([],[b]); f [] []  = ([],[])}
>>> comb22 f s1 s2
({2@0s},{0@0s,2@2s,3@6s,4@8s,5@9s})

A signal generator based on a function and a kernel value.

Constructors: generate[1-3].

>>> let ns a b = (map (+1) a,map (+2) b)
>>> let (s1,s2) = generate2 ns ((3,1),(1,2))
>>> takeS 5 s1
{1@0,2@3,3@6,4@9,5@12}
>>> takeS 7 s2
{2@0,4@1,6@2,8@3,10@4,12@5,14@6}

state is a state machine without an output decoder, which exports the next state. It reacts "instantaneously" with every triggering event, and has no oscillation behavior. Internally it embeds a clocked SY process (see state22).

Constructors: state[1-3][1-3].

>>> let s = readSignal "{1@1, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> state11 (\s [a] -> s + a) 1 s
{2@1s,4@2s,7@6s,11@8s,16@9s}

state is a state machine without an output decoder, which exports the current state. It reacts "instantaneously" with every triggering event, and has no oscillation behavior. Internally it embeds a clocked SY process (see stated22).

Constructors: stated[1-3][1-3].

>>> let s = readSignal "{1@1, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> stated11 (\s [a] -> s + a) 1 s
{1@1s,2@2s,4@6s,7@8s,11@9s}

moore processes model Moore state machines. It reacts "instantaneously" with every triggering event, and has no oscillation behavior. Internally it embeds a clocked SY process (see moore22).

Constructors: moore[1-3][1-3]

>>> let { ns s [a] [b] = s+a+b; ns s [] [b] = s; ns _ _ _ = 0 }
>>> let od s = [s + 1]
>>> let s1 = readSignal "{1@1, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> let s2 = readSignal "{1@2, 1@3, 3@6, 4@8, 5@9}" :: Signal Int
>>> moore21 ns od 1 s1 s2
{2@1s,1@2s,4@3s,4@6s,10@8s,18@9s}

mealy processes model Mealy state machines. It reacts "instantaneously" with every triggering event, and has no oscillation behavior. Internally it embeds a clocked SY process (see mealy22).

Constructors: mealy[1-4][1-4]

>>> let { ns s [a] [b] = s+a+b; ns s [] [b] = s; ns _ _ _ = 0 }
>>> let { od s [a] [b] = [s+a-b]; od s _ _ = [s] }
>>> let s1 = readSignal "{1@1, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> let s2 = readSignal "{1@2, 1@3, 3@6, 4@8, 5@9}" :: Signal Int
>>> mealy21 ns od 1 s1 s2
{1@1s,1@2s,3@3s,3@6s,9@8s,17@9s}

Synchronizes n signals and for each absent event at a synchronization point, it holds the previous non-absent one.

Constructors: syncAndHold[2-4]

>>> let s1 = readSignal "{1@1, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> let s2 = readSignal "{3@2, 4@4, 5@5, 6@8, 7@9}" :: Signal Int
>>> let (o1,o2) = syncAndHold2 (0,0) s1 s2
>>> o1
{1@1s,2@2s,2@4s,2@5s,3@6s,4@8s,5@9s}
>>> o2
{0@1s,3@2s,4@4s,5@5s,5@6s,6@8s,7@9s}

Synchronizes n signals and for each absent event at a synchronization point, it replaces it with an arbitrary user-defined value.

Constructors: syncAndFill[2-4]

>>> let s1 = readSignal "{1@1, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> let s2 = readSignal "{3@2, 4@4, 5@5, 6@8, 7@9}" :: Signal Int
>>> let (o1,o2) = syncAndFill2 (0,0) s1 s2
>>> o1
{1@1s,2@2s,0@4s,0@5s,3@6s,4@8s,5@9s}
>>> o2
{0@1s,3@2s,4@4s,5@5s,0@6s,6@8s,7@9s}

syncAndObs\(mn\) synchronizes \(m + n\) signals where the first \(m\) are triggering signals and the last \(n\) non-triggering (observed) signals.

Constructors: syncAndObs11, syncAndObs21, syncAndObs31, syncAndObs12, syncAndObs22, syncAndObs13.

>>> let s1 = readSignal "{1@1, 2@2, 3@6, 4@8, 5@9}" :: Signal Int
>>> let s2 = readSignal "{3@2, 4@4, 5@5, 6@8, 7@9}" :: Signal Int
>>> let (o1,o2) = syncAndObs11 0 s1 s2
>>> o1
{1@1s,2@2s,3@6s,4@8s,5@9s}
>>> o2
{0@1s,3@2s,4@4s,5@5s,5@6s,6@8s,7@9s}

Syntax-preserving transformation to the original conservative ForSyDe.Atom.MoC.DE MoC. It is not semantics-preserving because "instant" events are re-interpreted as "persistent".

OBS: all input signals need to start from global time 0.

>>> let s1 = RE.readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: RE.Signal Int
>>> let s2 = RE.readSignal "{1@0, 2@3, 3@4, 4@8, 5@10}" :: RE.Signal Int
>>> toDE2 s1 s2
({1@0s,2@2s,3@6s,4@8s,5@9s},{1@0s,2@3s,3@4s,4@8s,5@10s})

Syntax-preserving transformation from the original conservative ForSyDe.Atom.MoC.DE MoC. It is not semantics-preserving because "persistent" events are re-interpreted as "instant".

OBS: all input signals will start at global time 0.

>>> let s1 = DE.readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: DE.Signal Int
>>> let s2 = DE.readSignal "{1@0, 2@3, 3@4, 4@8, 5@10}" :: DE.Signal Int
>>> fromDE2 s1 s2
({1@0s,2@2s,3@6s,4@8s,5@9s},{1@0s,2@3s,3@4s,4@8s,5@10s})

Semantics-preserving translation to ForSyDe.Atom.MoC.SY.Clocked signals. At any synchronization instant, triggering events are wrapped into a Prst behavior, whereas absent ones are represented as Abst. The output signals are tupled with a (pure) SY signal carrying the timestamps of the synchronization points.

OBS: check the documentation of ForSyDe.Atom.MoC.SY.Clocked for legal multi-clock rate interactions.

Constructors: toSY[1-4]

>>> let s1 = RE.instant 1
>>> let s2 = RE.readSignal "{1@1, 2@2, 3@6, 4@8, 5@9}" :: RE.Signal Int
>>> toSYC2 s1 s2
({0s,1s,2s,6s,8s,9s},{1,⟂,⟂,⟂,⟂,⟂},{⟂,1,2,3,4,5})

Semantics-preserving translation from ForSyDe.Atom.MoC.SY.Clocked signals. Prst events are propagated, whereas Abst ones are cleaned from the output. The first signal needs to be a (pure) SY signal describing the timestamps of the synchronization points.

OBS: This process has cleaning behavior. It needs to be avoided from the datapath of any feedback loop!

Constructors: fromSY, fromSY2, fromSY3, fromSY4.

>>> let s1 = SY.signal [0,3,4,6,9] :: SY.Signal DE.TimeStamp
>>> let s2 = SY.signal [Prst 1,Prst 2,Abst,Prst 4,Prst 5]
>>> fromSYC1 s1 s2
{1@0s,2@3s,4@6s,5@9s}

Embeds a ForSyDe.Atom.MoC.SY.Clocked process inside a RE environment. Internally, it synchronizes the input signals, translates them to clocked SY (see toSYC2), feeds them to a SY process and translates the result back to RE (see fromSYC2) using the same input tags. Seen from outside, this process behaves like a RE process with "instantaneous response".

Constructors: embedSY[1-4][1-4].

For the following example, see the difference between its output and the one of stated22

>>> let s1 = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: RE.Signal Int
>>> let s2 = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: RE.Signal Int
>>> embedSY21 (SYC.stated21 (\s a b -> a + b - s) 1) s1 s2
{1@0s,1@2s,3@6s,3@8s,5@9s}

OBS: according to the ForSyDe.Atom.MoC.SY.Clocked MoC all inputs signals need to be sichronized (i.e. have the same clock rate), otherwise their interaction is illegal.

> let s1 = readSignal "{1@0, 2@2, 3@6, 4@8, 5@9}" :: RE.Signal Int
> let s2 = readSignal "{1@0, 2@2, 3@7, 4@8, 5@9}" :: RE.Signal Int
> embedSY21 (SYC.stated21 (\s a b -> a + b - s) 1) s1 s2
 {1@0s,1@2s,3@6s,*** Exception: [ExB.Absent] Illegal occurrence of an absent and present event

The equivalent of a timer set to period 0 in LF. It triggers once at the beginning of the execution and then it never triggers again.

A timer signal generator

Like timer, but you can specify an initial phase.

A delayed action is simply a delayed signal. In ForSyDe the initial value is mandatory. If there is a notion of unknown, this has to be captured by the domain a of the event (i.e. "one layer below").

Alias for syncAndObs11. Denotes which actions come from states (with persistent values) and which come from other actions or inputs (instantaneous).

>>> let sts = read "{1@0,2@3,3@6,4@10,5@13}" :: Signal Int
>>> let ins = read "{1@3,2@4,3@5,4@6,5@13}"  :: Signal Int
>>> states1inputs1 0 sts ins
({1@3s,2@4s,3@5s,4@6s,5@13s},{1@0s,2@3s,2@4s,2@5s,3@6s,4@10s,5@13s})

Alias for comb22, tupled version, that can be chained directly from a statesXinputsY "utility", see states2inputs2.

>>> let sts = read "{1@0,2@3,3@6,4@10,5@13}" :: Signal Int
>>> let ins = read "{1@3,2@4,3@5,4@6,5@13}"  :: Signal Int
>>> reaction21 (\a b -> [sum a + sum b]) $ states1inputs1 0 sts ins
{1@0s,3@3s,4@4s,5@5s,7@6s,4@10s,10@13s}