Struct KeyedSingleton 

pub struct KeyedSingleton<K, V, Loc, Bound> { /* private fields */ }

Implementations

impl<'a, K, V, L: Location<'a>> KeyedSingleton<K, V, Tick<L>, Bounded>

pub fn entries(self) -> Stream<(K, V), Tick<L>, Bounded, NoOrder, ExactlyOnce>

pub fn values(self) -> Stream<V, Tick<L>, Bounded, NoOrder, ExactlyOnce>

pub fn keys(self) -> Stream<K, Tick<L>, Bounded, NoOrder, ExactlyOnce>

impl<'a, K, V, L: Location<'a>, B> KeyedSingleton<K, V, L, B>

pub fn map<U, F>( self, f: impl IntoQuotedMut<'a, F, L> + Copy, ) -> KeyedSingleton<K, U, L, B>

where F: Fn(V) -> U + 'a,

pub fn filter<F>( self, f: impl IntoQuotedMut<'a, F, L> + Copy, ) -> KeyedSingleton<K, V, L, B>

where F: Fn(&V) -> bool + 'a,

pub fn filter_map<F, U>( self, f: impl IntoQuotedMut<'a, F, L> + Copy, ) -> KeyedSingleton<K, U, L, B>

where F: Fn(V) -> Option<U> + 'a,

pub fn key_count(self) -> Singleton<usize, L, B>

pub fn ir_node_named(self, name: &str) -> KeyedSingleton<K, V, L, B>

An operator which allows you to “name” a HydroNode. This is only used for testing, to correlate certain HydroNodes with IDs.

impl<'a, K: Hash + Eq, V, L: Location<'a>> KeyedSingleton<K, V, Tick<L>, Bounded>

pub fn get( self, key: Singleton<K, Tick<L>, Bounded>, ) -> Optional<V, Tick<L>, Bounded>

Gets the value associated with a specific key from the keyed singleton.

Example

let tick = process.tick();
let keyed_data = process
    .source_iter(q!(vec![(1, 2), (2, 3)]))
    .into_keyed()
    .batch(&tick, nondet!(/** test */))
    .fold(q!(|| 0), q!(|acc, x| *acc = x));
let key = tick.singleton(q!(1));
keyed_data.get(key).all_ticks()
// 2

pub fn get_many<O2, R2, V2>( self, with: KeyedStream<K, V2, Tick<L>, Bounded, O2, R2>, ) -> KeyedStream<K, (V, V2), Tick<L>, Bounded, NoOrder, R2>

Given a keyed stream of lookup requests, where the key is the lookup and the value is some additional metadata, emits a keyed stream of lookup results where the key is the same as before, but the value is a tuple of the lookup result and the metadata of the request.

Example

let tick = process.tick();
let keyed_data = process
    .source_iter(q!(vec![(1, 10), (2, 20)]))
    .into_keyed()
    .batch(&tick, nondet!(/** test */))
    .fold(q!(|| 0), q!(|acc, x| *acc = x));
let other_data = process
    .source_iter(q!(vec![(1, 100), (2, 200), (1, 101)]))
    .into_keyed()
    .batch(&tick, nondet!(/** test */));
keyed_data.get_many(other_data).entries().all_ticks()
// { 1: [(10, 100), (10, 101)], 2: [(20, 200)] } in any order

pub fn latest(self) -> KeyedSingleton<K, V, L, Unbounded>

impl<'a, K, V, L, B> KeyedSingleton<K, V, L, B>

where L: Location<'a> + NoTick + NoAtomic,

pub fn atomic(self, tick: &Tick<L>) -> KeyedSingleton<K, V, Atomic<L>, B>

pub fn snapshot( self, tick: &Tick<L>, nondet: NonDet, ) -> KeyedSingleton<K, V, Tick<L>, Bounded>

Given a tick, returns a keyed singleton with a entries consisting of keys with snapshots of the value singleton.

Non-Determinism

Because this picks a snapshot of each singleton whose value is continuously changing, the output singleton has a non-deterministic value since each snapshot can be at an arbitrary point in time.

impl<'a, K, V, L, B> KeyedSingleton<K, V, Atomic<L>, B>

where L: Location<'a> + NoTick + NoAtomic,

pub fn snapshot(self, _nondet: NonDet) -> KeyedSingleton<K, V, Tick<L>, Bounded>

Returns a keyed singleton with a entries consisting of keys with snapshots of the value singleton being atomically processed.

Non-Determinism

Because this picks a snapshot of each singleton whose value is continuously changing, each output singleton has a non-deterministic value since each snapshot can be at an arbitrary point in time.

Trait Implementations

impl<'a, K: Clone, V: Clone, Loc: Location<'a>, Bound> Clone for KeyedSingleton<K, V, Loc, Bound>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, K, V, L, B> CycleCollection<'a, ForwardRefMarker> for KeyedSingleton<K, V, L, B>

where L: Location<'a> + NoTick,

type Location = L

fn create_source(ident: Ident, location: L) -> Self

impl<'a, K, V, L, B> CycleComplete<'a, ForwardRefMarker> for KeyedSingleton<K, V, L, B>

where L: Location<'a> + NoTick,

fn complete(self, ident: Ident, expected_location: LocationId)