Alias showing that in the ForSyDe.Atom.MoC.SY.Clocked domain, a signal is considered a stream of absent-extended SY events.

The pre construct in Lustre. OBS: instead of nil, the first value is an Abst. TODO: unclear if this breaks the SY assumption.

>>> let s1 = signal [Prst 1, Prst 2, Prst 3, Prst 4, Prst 5]
>>> pre s1
{⟂,1,2,3,4,5}

The -> operator in Lustre.

>>> let s1 = signal [Prst 1, Prst 2, Prst 3, Prst 4, Prst 5]
>>> unit (Prst 10) ->- s1
{10,2,3,4,5}

Determines the existence of events in the (left) signal based on the (right) signal of boolean values (conditions). In Lustre this construct is used to generate other clock rates.

>>> let s1   = (signal . map Prst) [1,2,3,4,5]
>>> let pred = signal [Prst False, Abst, Prst True, Prst False, Prst True]
>>> s1 `when` pred
{⟂,⟂,3,⟂,5}

Holds the last non-absent value in a signal, like the current construct in Lustre. OBS: instead of nil, the first value is user-defined.

>>> let s1   = signal [Abst, Abst, Prst 1, Prst 2, Abst, Prst 3]
>>> current 0 s1
{0,0,1,2,2,3}

Applies a predicate function on a signal of absent-extended events.

>>> let s1   = signal $ map Prst [1,2,3,4,5]
>>> s1 `is` (>3)
{False,False,False,True,True}

It is useful in combination with when.

>>> let s1 = (signal . map Prst) [1,2,3,4,5]
>>> let s2 = (signal . map Prst) [11,22,33,44,55]
>>> s2 `when` (s1 `is` (>3))
{⟂,⟂,⟂,44,55}

Serializes when with is for up to three input signals.

Constructors whenIs[1-3]

>>> let s1 = (signal . map Prst) [1,2,3,4,5]
>>> let s2 = (signal . map Prst) [11,22,33,44,55]
>>> whenIs2 (>3) s1 s1 s2
({⟂,⟂,⟂,4,5},{⟂,⟂,⟂,44,55})

Same as whenIs2 but triggering the output events only based on the presence of the first input rather than a boolean.

>>> let s1 = signal $ map Prst [1,2,3,4,5]
>>> let sp = signal [Prst 1, Prst 1, Abst, Prst 1, Abst]
>>> whenPres1 sp s1
{1,2,⟂,4,⟂}

Filters out values to Abst if they do not fulfill a predicate function, i.e. applies whenIs1 on itself.

>>> let s1   = (signal . map Prst) [1,2,3,4,5]
>>> filter (>3) s1
{⟂,⟂,⟂,4,5}

Fills absent events with a user-defined value.

>>> let s1   = signal [Abst, Abst, Prst 1, Prst 2, Abst, Prst 3]
>>> fill 0 s1
{0,0,1,2,0,3}

The delay process "delays" a signal with one event. Serializes a pre and a ->-.

>>> let s = signal [Prst 1,Prst 2,Prst 3,Abst,Prst 5]
>>> delay 0 s
{0,1,2,3,⟂,5}

comb processes map combinatorial functions on signals on synchronized input signals. It implements the comb pattern (see comb22), and implicitly applies a resolution between absent-extended events (see res22)

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

>>> let s1 = (signal . map Prst) [1..]
>>> let s2 = signal [Prst 1,Prst 1,Abst,Prst 1,Prst 1]
>>> comb11 (+1) s2
{2,2,⟂,2,2}
>>> comb22 (\a b-> (a+b,a-b)) s2 s2
({2,2,⟂,2,2},{0,0,⟂,0,0})

Combining two signals at different clock rates throws a runtime error:

comb22 (\a b-> (a+b,a-b)) s1 s2
({2,3,*** Exception: [ExB.Absent] Illegal occurrence of an absent and present event

stated is a state machine without an output decoder. It implements the stated pattern (see stated22), and operates on degenerated absent-extended values (see ignore22) in order to propagate absent events properly and not raise absent-present resolution errors.

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

>>> let ones = takeS 8 $ SY.constant1 (Prst 1)
>>> let b = (signal . map Prst) [False,True,False,False,True,True,False,True]
>>> ones
{1,1,1,1,1,1,1,1}
>>> b
{False,True,False,False,True,True,False,True}
>>> stated11 (+) 1 ones
{1,2,3,4,5,6,7,8}
>>> stated11 (+) 1 (ones `when` b)
{⟂,1,⟂,⟂,2,3,⟂,4}
>>> stated11 (+) 1 ones `when` b
{⟂,2,⟂,⟂,5,6,⟂,8}

state is a state machine without an output decoder, that reacts instantaneously. It implements the state pattern (see state22), and operates on degenerated absent-extended values (see ignore22) in order to propagate absent events properly and not raise absent-present resolution errors.

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

>>> let ones = takeS 8 $ SY.constant1 (Prst 1)
>>> let b = (signal . map Prst) [False,True,False,False,True,True,False,True]
>>> ones
{1,1,1,1,1,1,1,1}
>>> b
{False,True,False,False,True,True,False,True}
>>> state11 (+) 1 ones
{2,3,4,5,6,7,8,9}
>>> state11 (+) 1 (ones `when` b)
{⟂,2,⟂,⟂,3,4,⟂,5}
>>> state11 (+) 1 ones `when` b
{⟂,3,⟂,⟂,6,7,⟂,9}

moore processes model Moore state machines. It implements the moore patterns (see moore22), and operates on absent-extended values (see stated22).

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

>>> let s1 = signal [Prst 1,Prst 2,Abst,Abst,Prst 3]
>>> moore11 (+) (+1) 1 s1
{2,3,⟂,⟂,5}

mealy processes model Mealy state machines. It implements the mealy pattern (see mealy22), and operates on absent-extended values (see stated22).

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

>>> let s1 = signal [Prst 1,Prst 2,Abst,Abst,Prst 3]
>>> mealy11 (+) (+) 1 s1
{2,4,⟂,⟂,7}