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

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

where L: NoTick,

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

where T: Clone,

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 forward_ref<S>(&self) -> (ForwardHandle<'a, S>, S)

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

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

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

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

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

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

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

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

fn id(&self) -> LocationId

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

where T: Clone, Self: Sized,

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

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

where L: Location<'a>,