Simple unidirectional valid-ready protocol.

Never produce a value.

Acknowledge but ignore data from LHS protocol. Send a static value b.

Always acknowledge and ignore values.

Never acknowledge values.

Drive a constant value composed of a.

Like map, but over payload (a) of a Df stream.

Like map, but can reason over signals.

Like map, but over payload (a) of a Df stream.

Like bimap, but can reason over signals.

Like fst, but over payload of a Df stream.

Like snd, but over payload of a Df stream.

Like mapMaybe, but over payload (a) of a Df stream.

Like catMaybes, but over a Df stream.

Example:

>>> take 2 (simulateCS (catMaybes @C.System @Int) [Nothing, Just 1, Nothing, Just 3])
[1,3]

Coerce the payload of a Df stream.

Takes one or more values from the left and "compresses" it into a single value that is occasionally sent to the right. Useful for taking small high-speed inputs (like bits from a serial line) and turning them into slower wide outputs (like 32-bit integers).

Example:

>>> accumulate xs x = let xs' = x:xs in if length xs' == 3 then ([], Just xs') else (xs', Nothing)
>>> circuit = C.exposeClockResetEnable (compressor @C.System [] accumulate)
>>> take 2 (simulateCSE circuit [(1::Int),2,3,4,5,6,7])
[[3,2,1],[6,5,4]]

Takes a value from the left and "expands" it into one or more values that are sent off to the right. Useful for taking wide, slow inputs (like a stream of 32-bit integers) and turning them into a fast, narrow output (like a stream of bits).

Example:

>>> step index = if index == maxBound then (0, True) else (index + 1, False)
>>> expandVector index vec = let (index', done) = step index in (index', vec C.!! index, done)
>>> circuit = C.exposeClockResetEnable (expander @C.System (0 :: C.Index 3) expandVector)
>>> take 6 (simulateCSE circuit [1 :> 2 :> 3 :> Nil, 4 :> 5 :> 6 :> Nil])
[1,2,3,4,5,6]

Takes values from the left, possibly holding them there for a while while working on them, and occasionally sends values off to the right. Used to implement both expander and compressor, so you can use it when there's not a straightforward one-to-many or many-to-one relationship between the input and output streams.

Like filter, but over a Df stream.

Example:

>>> take 3 (simulateCS (filter @C.System @Int (>5)) [1, 5, 7, 10, 3, 11])
[7,10,11]

Like filter, but can reason over signals.

Like either, but over a Df stream.

Like either, but can reason over signals.

Like first, but over payload of a Df stream.

Like first, but can reason over signals.

Like mapLeft, but over payload of a Df stream.

Like mapLeft, but can reason over signals.

Like second, but over payload of a Df stream.

Like second, but can reason over signals.

Like mapRight, but over payload of a Df stream.

Like mapRight, but can reason over signals.

Like zipWith, but over two Df streams.

Example:

>>> take 3 (simulateCS (zipWith @C.System @Int (+)) ([1, 3, 5], [2, 4, 7]))
[3,7,12]

Like zipWith, but can reason over signals.

Like zip, but over two Df streams.

Like partition, but over Df streams

Example:

>>> let input = [1, 3, 5, 7, 9, 2, 11]
>>> let output = simulateCS (partition @C.System @Int (>5)) input
>>> B.bimap (take 3) (take 4) output
([7,9,11],[1,3,5,2])

Like partitionEithers, but over Df streams

Example:

>>> let input = [Left 1, Right 'a', Left 2, Right 'b']
>>> let output = simulateCS (partitionEithers @C.System @Int @Char) input
>>> B.bimap (take 2) (take 2) output
([1,2],"ab")

Like partition, but can reason over signals.

Route a Df stream to another corresponding to the index

Example:

>>> let input = [(0, 3), (0, 5), (1, 7), (2, 13), (1, 11), (2, 1)]
>>> let output = simulateCS (route @3 @C.System @Int) input
>>> fmap (take 2) output
[3,5] :> [7,11] :> [13,1] :> Nil

Select data from the channel indicated by the Df stream carrying Index n.

Example:

>>> let indices = [1, 1, 2, 0, 2]
>>> let dats = [8] :> [5, 7] :> [9, 1] :> Nil
>>> let output = simulateCS (select @3 @C.System @Int) (dats, indices)
>>> take 5 output
[5,7,9,8,1]

Select selectN samples from channel n.

Example:

>>> let indices = [(0, 2), (1, 3), (0, 2)]
>>> let dats = [10, 20, 30, 40] :> [11, 22, 33] :> Nil
>>> let circuit = C.exposeClockResetEnable (selectN @2 @10 @C.System @Int)
>>> take 7 (simulateCSE circuit (dats, indices))
[10,20,11,22,33,30,40]

Selects samples from channel n until the predicate holds. The cycle in which the predicate turns true is included.

Example:

>>> let indices = [0, 0, 1, 2]
>>> let channel1 = [(10, False), (20, False), (30, True), (40, True)]
>>> let channel2 = [(11, False), (21, True)]
>>> let channel3 = [(12, False), (22, False), (32, False), (42, True)]
>>> let dats = channel1 :> channel2 :> channel3 :> Nil
>>> take 10 (simulateCS (selectUntil @3 @C.System @(Int, Bool) P.snd) (dats, indices))
[(10,False),(20,False),(30,True),(40,True),(11,False),(21,True),(12,False),(22,False),(32,False),(42,True)]

Like selectUntil, but can reason over signals.

Merge data of multiple Df streams using a user supplied function

Like fanin, but can reason over signals.

Merge data of multiple Df streams using Monoid's <>.

Copy data of a single Df stream to multiple. LHS will only receive an acknowledgement when all RHS receivers have acknowledged data.

Bundle a vector of Df streams into one.

Split up a Df stream of a vector into multiple independent Df streams.

Distribute data across multiple components on the RHS. Useful if you want to parallelize a workload across multiple (slow) workers. For optimal throughput, you should make sure workers can accept data every n cycles.

Collect modes for dataflow arbiters.

Opposite of roundrobin. Useful to collect data from workers that only produce a result with an interval of n cycles.

Place register on forward part of a circuit. This adds combinational delay on the backward path.

Place register on backward part of a circuit. This adds combinational delay on the forward path.

A fifo buffer with user-provided depth. Uses blockram to store data. Can handle simultaneous write and read (full throughput rate).

Convert a Df stream to a Maybe stream. Never stalls LHS.

Convert a Maybe stream to a Df stream. Not every Just is guaranteed to be forwarded to the RHS because of potential backpressure. The number of dropped Justs is exported as an unsigned number. Note that this circuit uses the clock supplied through the HiddenClockResetEnable constraint to latch the incoming Maybe values in case of backpressure from the RHS. This makes it adhere to the rules of the Df protocol.

Force a nack on the backward channel and no data on the forward channel if reset is asserted.