Struct Delta 

pub struct Delta<I, T> { /* private fields */ }

Delta of items.

This data type represents a collection of items that can include insertions and deletions (if Option is None), which we call deltas. Deltas are the means of differentially passing changes through a stream. They must be applied to a store to manifest the changes they represent.

Note that deltas are assumed to always only contain unique items, meaning there are no two items with the same identifier in a delta. This invariant must be checked with unit tests (which we provide for our operators), but is not enforced at runtime for performance reasons. Differential semantics still hold if this invariant is violated, but performance might be impacted due to unnecessary re-computations.

Examples

use zrx_scheduler::effect::Item;
use zrx_stream::value::Delta;

// Create delta of items
let delta = Delta::from([
    Item::new("a", Some(1)),
    Item::new("b", Some(2)),
    Item::new("c", Some(3)),
]);

Implementations

impl<I, T> Delta<I, T>

pub fn iter(&self) -> Iter<'_, Item<I, Option<T>>>

Creates an iterator over the delta of items.

Examples

use zrx_scheduler::effect::Item;
use zrx_stream::value::Delta;

// Create delta of items
let delta = Delta::from([
    Item::new("a", Some(1)),
    Item::new("b", Some(2)),
    Item::new("c", Some(3)),
]);

// Create iterator over items
for item in delta.iter() {
    println!("{item:?}");
}

Trait Implementations

impl<I: Clone, T: Clone> Clone for Delta<I, T>

fn clone(&self) -> Delta<I, T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug, T: Debug> Debug for Delta<I, T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<I, T> Default for Delta<I, T>

fn default() -> Self

Creates an empty delta of items.

Examples

use zrx_stream::value::Delta;

// Create empty delta of items
let delta = Delta::default();

impl<I, T, U, const N: usize> From<[U; N]> for Delta<I, T>

where U: Into<Item<I, Option<T>>>,

fn from(value: [U; N]) -> Self

Creates a delta of items from a slice of items.

Examples

use zrx_scheduler::effect::Item;
use zrx_stream::value::Delta;

// Create delta of items
let delta = Delta::from([
    Item::new("a", Some(1)),
    Item::new("b", Some(2)),
    Item::new("c", Some(3)),
]);

impl<I, T, U> FromIterator<U> for Delta<I, T>

where U: Into<Item<I, Option<T>>>,

fn from_iter<V>(iter: V) -> Self

where V: IntoIterator<Item = U>,

Creates a delta of items from an iterator.

Examples

use zrx_scheduler::effect::Item;
use zrx_stream::value::Delta;

// Create delta of items
let delta = Delta::from_iter([
    Item::new("a", Some(1)),
    Item::new("b", Some(2)),
    Item::new("c", Some(3)),
]);

impl<'a, I, T> IntoIterator for &'a Delta<I, T>

fn into_iter(self) -> Self::IntoIter

Creates an iterator over the delta of items.

Examples

use zrx_scheduler::effect::Item;
use zrx_stream::value::Delta;

// Create delta of items
let delta = Delta::from([
    Item::new("a", Some(1)),
    Item::new("b", Some(2)),
    Item::new("c", Some(3)),
]);

// Create iterator over items
for item in &delta {
    println!("{item:?}");
}

type Item = &'a Item<I, Option<T>>

The type of the elements being iterated over.

type IntoIter = Iter<'a, Item<I, Option<T>>>

Which kind of iterator are we turning this into?

impl<I, T> IntoIterator for Delta<I, T>

fn into_iter(self) -> Self::IntoIter

Creates an iterator over the delta of items.

Examples

use zrx_scheduler::effect::Item;
use zrx_stream::value::Delta;

// Create delta of items
let delta = Delta::from([
    Item::new("a", Some(1)),
    Item::new("b", Some(2)),
    Item::new("c", Some(3)),
]);

// Create iterator over items
for item in delta {
    println!("{item:?}");
}

type Item = Item<I, Option<T>>

The type of the elements being iterated over.

type IntoIter = IntoIter<<Delta<I, T> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

impl<I, T> Value for Delta<I, T>

where I: Id, T: Value,