The SY event. It defines a synchronous signal.

Type synonym for a SY signal, i.e. "an ordered stream of SY events"

Wraps a (tuple of) value(s) into the equivalent unit signal(s). A unit signal is a signal with one event, i.e. a singleton.

Provided helpers: unit, unit2, unit3, unit4.

Transforms a list of values into a SY signal.

Reads a signal from a string. Like with the read function from Prelude, you must specify the type of the signal.

>>> readSignal "{1,2,3,4,5}" :: Signal Int
{1,2,3,4,5}

The delay process "delays" a signal with one event. Instantiates the delay pattern.

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

comb processes map combinatorial functions on signals and take care of synchronization between input signals. It implements the comb pattern (see comb22).

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

>>> let s1 = signal [1..]
>>> let s2 = signal [1,1,1,1,1]
>>> comb11 (+1) s2
{2,2,2,2,2}
>>> comb22 (\a b-> (a+b,a-b)) s1 s2
({2,3,4,5,6},{0,1,2,3,4})

reconfig creates an synchronous adaptive process where the first signal carries functions and the other carry the arguments. It imlements the reconfig pattern (see reconfig22).

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

>>> let sf = signal [(+1),(*2),(+1),(*2),(+1),(*2),(+1)]
>>> let s1 = signal [1..]
>>> reconfig11 sf s1
{2,4,4,8,6,12,8}

A signal generator which keeps a value constant. It implements rgw stated0X pattern (see stated22).

Constructors: constant[1-4].

>>> let (s1, s2) = constant2 (1,2)
>>> takeS 3 s1
{1,1,1}
>>> takeS 5 s2
{2,2,2,2,2}

A signal generator based on a function and a kernel value. It implements the stated0X pattern (check stated22).

Constructors: generate[1-4].

>>> let (s1,s2) = generate2 (\a b -> (a+1,b+2)) (1,2)
>>> takeS 5 s1
{1,2,3,4,5}
>>> takeS 7 s2
{2,4,6,8,10,12,14}

stated is a state machine without an output decoder. It implements the stated pattern (see stated22).

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

>>> let s1 = signal [1,2,3,4,5]
>>> stated11 (+) 1 s1
{1,2,4,7,11,16}

state is a state machine without an output decoder. It implements the stated pattern (see state22).

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

>>> let s1 = signal [1,2,3,4,5]
>>> state11 (+) 1 s1
{2,4,7,11,16}

moore processes model Moore state machines. It implements the moore patterns (see moore22).

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

>>> let s1 = signal [1,2,3,4,5]
>>> moore11 (+) (+1) 1 s1
{2,3,5,8,12,17}

mealy processes model Mealy state machines. It implements the mealy pattern (see mealy22).

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

>>> let s1 = signal [1,2,3,4,5]
>>> mealy11 (+) (-) 1 s1
{0,0,1,3,6}

Wraps explicit timestamps to a (set of) SY signal(s), rendering the equivalent synchronized DE signal(s).

Constructors: toDE, toDE2, toDE3, toDE4.

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

Transforms a (set of) SY signal(s) into the equivalent SDF signal(s). The only change is the event consructor, meaning that the order is preserved.

Constructors: toSDF[1-4].

>>> let s = SY.signal [1,2,3,4,5]
>>> toSDF1 s
{1,2,3,4,5}

Transforms a (set of) SY signal(s) of vectors of the same length into equivanlent SDF signal(s) by serializing the vectors according to a production rate. If the production rate and the vector lengths do not match then a runtime error is thrown.

Constructors: toSDF[1-4]'.

>>> let s = read "{<1,2>,<3,4>,<5,6>}" :: SY.Signal (V.Vector Int)
>>> toSDF1' 2 s
{1,2,3,4,5,6}

Synchronizes all the signals contained by a vector and zips them into one signal of vectors. It instantiates the zipx skeleton.

>>> let s1 = SY.signal [1,2,3,4,5]
>>> let s2 = SY.signal [11,12,13,14,15]
>>> let v1 = V.vector [s1,s1,s2,s2]
>>> v1
<{1,2,3,4,5},{1,2,3,4,5},{11,12,13,14,15},{11,12,13,14,15}>
>>> zipx v1
{<1,1,11,11>,<2,2,12,12>,<3,3,13,13>,<4,4,14,14>,<5,5,15,15>}

Unzips the vectors carried by a signal into a vector of signals. It instantiates the unzipx skeleton. To avoid infinite recurrence, the user needs to provide the length of the output vector.

>>> let v1 = V.vector [1,2,3,4]
>>> let s1 = SY.signal [v1,v1,v1,v1,v1]
>>> s1
{<1,2,3,4>,<1,2,3,4>,<1,2,3,4>,<1,2,3,4>,<1,2,3,4>}
>>> unzipx 4 s1
<{1,1,1,1,1},{2,2,2,2,2},{3,3,3,3,3},{4,4,4,4,4}>

Same as unzipx, but "sniffs" the first event to determine the length of the output vector. Has an unsafe behavior!

>>> let v1 = V.vector [1,2,3,4]
>>> let s1 = SY.signal [v1,v1,v1,v1,v1]
>>> s1
{<1,2,3,4>,<1,2,3,4>,<1,2,3,4>,<1,2,3,4>,<1,2,3,4>}
>>> unzipx' s1
<{1,1,1,1,1},{2,2,2,2,2},{3,3,3,3,3},{4,4,4,4,4}>