Struct Tick 

pub struct Tick<L> { /* private fields */ }

Marks the stream as being inside the single global clock domain.

Implementations

impl<'a, L> Tick<L>

where L: Location<'a>,

pub fn outer(&self) -> &L

Returns a reference to the outer (parent) location that this tick is nested within.

For example, if a Tick was created from a Process, this returns a reference to that Process.

pub fn spin_batch( &self, batch_size: impl QuotedWithContext<'a, usize, L> + Copy + 'a, ) -> Stream<(), Self, Bounded, TotalOrder, ExactlyOnce>

where L: NoTick,

Creates a bounded stream of () values inside this tick, with a fixed batch size.

This is useful for driving computations inside a tick that need to process a specific number of elements per tick. Each tick will produce exactly batch_size unit values.

pub fn singleton<T>( &self, e: impl QuotedWithContext<'a, T, Tick<L>>, ) -> Singleton<T, Self, Bounded>

where T: Clone,

Constructs a Singleton materialized inside this tick with the given static value.

The singleton will have the provided value on every tick. This is useful for providing constant values to computations inside a tick.

pub fn none<T>(&self) -> Optional<T, Self, Bounded>

Creates an Optional which has a null value on every tick.

Example

let tick = process.tick();
let optional = tick.none::<i32>();
optional.unwrap_or(tick.singleton(q!(123)))
// 123

pub fn optional_first_tick<T: Clone>( &self, e: impl QuotedWithContext<'a, T, Tick<L>>, ) -> Optional<T, Self, Bounded>

Creates an Optional which will have the provided static value on the first tick, and be null on all subsequent ticks.

This is useful for bootstrapping stateful computations which need an initial value.

Example

let tick = process.tick();
// ticks are lazy by default, forces the second tick to run
tick.spin_batch(q!(1)).all_ticks().for_each(q!(|_| {}));
let optional = tick.optional_first_tick(q!(5));
optional.unwrap_or(tick.singleton(q!(123))).all_ticks()
// 5, 123, 123, 123, ...

pub fn cycle<S>(&self) -> (TickCycleHandle<'a, S>, S)

where S: CycleCollection<'a, TickCycle, Location = Self> + DeferTick, L: NoTick,

Creates a feedback cycle within this tick for implementing iterative computations.

Returns a handle that must be completed with the actual collection, and a placeholder collection that represents the output of the previous tick (deferred by one tick). This is useful for implementing fixed-point computations where the output of one tick feeds into the input of the next.

The cycle automatically defers values by one tick to prevent infinite recursion.

pub fn cycle_with_initial<S>(&self, initial: S) -> (TickCycleHandle<'a, S>, S)

where S: CycleCollectionWithInitial<'a, TickCycle, Location = Self>,

Creates a feedback cycle with an initial value for the first tick.

Similar to Tick::cycle, but allows providing an initial collection that will be used as the value on the first tick before any feedback is available. This is useful for bootstrapping iterative computations that need a starting state.

Trait Implementations

impl<L: Clone> Clone for Tick<L>

fn clone(&self) -> Tick<L>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'a, L> Location<'a> for Tick<L>

where L: Location<'a>,

type Root = <L as Location<'a>>::Root

The root location type for this location.

fn root(&self) -> Self::Root

Returns the root location for this location.

fn try_tick(&self) -> Option<Tick<Self>>

Attempts to create a new Tick clock domain at this location.

fn id(&self) -> LocationId

Returns the unique identifier for this location.

fn singleton<T>( &self, e: impl QuotedWithContext<'a, T, Self>, ) -> Singleton<T, Self, Bounded>

where T: Clone, Self: Sized,

Constructs a Singleton materialized at this location with the given static value.

fn forward_ref<S>(&self) -> (ForwardHandle<'a, S>, S)

where S: CycleCollection<'a, ForwardRef, Location = Self>,

Creates a forward reference for defining recursive or mutually-dependent dataflows.

impl<'a, L> NoAtomic for Tick<L>

where L: Location<'a>,