Struct Stamp 

pub struct Stamp<T> { /* private fields */ }

A multiset of timestamps affixed to a message, stored sorted.

The elements are stored in increasing order under Ord so that Eq, Ord, and Hash are structural. Stamps built by insertion are minimal antichains; stamps mapped across scope boundaries may contain comparable or duplicate elements, whose multiplicities are significant for progress accounting.

Equality compares multisets, not the sets of times they contain: {a} and {a, a} are different stamps, as they are accounted differently.

As with Antichain, the storage holds a single element inline, so the overwhelmingly common zero- and one-element stamps require no allocation.

Implementations

impl<T> Stamp<T>

pub fn new() -> Self

An empty stamp, making no progress claims.

pub fn from_elem(element: T) -> Self

A stamp containing a single element.

pub fn elements(&self) -> &[T]

The elements of the stamp, in increasing Ord order.

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

An iterator over the elements of the stamp.

pub fn is_empty(&self) -> bool

True iff the stamp contains no elements.

pub fn len(&self) -> usize

The number of elements in the stamp.

pub fn into_elements(self) -> Vec<T>

The elements of the stamp, by value, in increasing Ord order.

pub fn as_singleton(&self) -> Option<&T>

The sole element of the stamp, if the stamp is a singleton.

pub fn expect_singleton(&self) -> &T

where T: Debug,

The sole element of the stamp; panics if the stamp is not a singleton.

This supports pre-stamp interfaces that insist on a single timestamp per message; such interfaces cannot be used with multi- or zero-element stamps.

impl<T: TotalOrder> Stamp<T>

pub fn least(&self) -> Option<&T>

The least element of the stamp, if the stamp is non-empty.

Only totally ordered stamps have a least element. A non-empty stamp over a total order has one however many elements it contains, and it is the time at which the message may first result in downstream work.

Elements are stored in Ord order, but TotalOrder speaks only of PartialOrder and need not agree with Ord, so this is a reduction rather than first().

impl<T: PartialOrder + Ord> Stamp<T>

pub fn insert(&mut self, element: T) -> bool

Inserts element unless it is redundant, removing elements it dominates.

Returns true iff the element was inserted.

pub fn less_equal(&self, time: &T) -> bool

True iff some element of the stamp is less or equal to time.

pub fn map_into<T2: PartialOrder + Ord>( &self, logic: impl FnMut(&T) -> Option<T2>, ) -> Stamp<T2>

Maps each element through logic, discarding None results and restoring minimality and canonical order.

This is the shape required when timestamps traverse path summaries (feedback edges), where elements may fail to traverse, or may become comparable after mapping. It may only be used by operators that account for their own consumed and produced messages, as it changes the number of pointstamps a message is accounted at.

pub fn map_pointwise<T2: Ord>(&self, logic: impl FnMut(&T) -> T2) -> Stamp<T2>

Maps each element through logic, preserving the number of elements and restoring sorted order, but not minimality.

This is the shape required at scope boundaries (enter and leave), whose produced and consumed accounting is inferred independently at either end of the channel from the stamp itself: the counts must agree element-wise, so the map must not collapse elements that become comparable or equal after mapping (as when leaving a scope projects away a timestamp coordinate). The resulting stamp may contain comparable or duplicate elements; this weakens no guarantee, as the stamp promises only that message contents are greater or equal to some element.

Trait Implementations

impl<T: Clone> Clone for Stamp<T>

fn clone(&self) -> Stamp<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T> Columnar for Stamp<T>

where SmallVec<[T; 1]>: Columnar,

type Container = StampContainer<<SmallVec<[T; 1]> as Columnar>::Container>

The type that stores the columnar representation.

fn copy_from<'a>(&mut self, other: Ref<'a, Self>)

Repopulates self from a reference.

fn into_owned<'a>(other: Ref<'a, Self>) -> Self

Produce an instance of Self from Self::Ref<'a>.

fn as_columns<'a, I>(selves: I) -> Self::Container

where I: IntoIterator<Item = &'a Self>, Self: 'a,

Converts a sequence of the references to the type into columnar form.

fn into_columns<I>(selves: I) -> Self::Container

where I: IntoIterator<Item = Self>, Self: Sized,

Converts a sequence of the type into columnar form.

fn reborrow<'b, 'a>( thing: <Self::Container as Borrow>::Ref<'a>, ) -> <Self::Container as Borrow>::Ref<'b>

where 'a: 'b,

Reborrows the reference type to a shorter lifetime.

impl<T: Debug> Debug for Stamp<T>

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

Formats the value using the given formatter.

impl<T> Default for Stamp<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Deserialize<'de> + Ord> Deserialize<'de> for Stamp<T>

Deserialization sorts the elements, as the bytes need not come from a valid Stamp.

fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error>

Deserialize this value from the given Serde deserializer.

impl<T: Eq> Eq for Stamp<T>

impl<T: PartialOrder + Ord + Clone> From<Antichain<T>> for Stamp<T>

fn from(antichain: Antichain<T>) -> Self

Converts to this type from the input type.

impl<T: PartialOrder + Ord + Clone> From<Stamp<T>> for Antichain<T>

fn from(stamp: Stamp<T>) -> Self

Converts to this type from the input type.

impl<T: PartialOrder + Ord> FromIterator<T> for Stamp<T>

fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self

Creates a value from an iterator.

impl<T: Hash> Hash for Stamp<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'a, T> IntoIterator for &'a Stamp<T>

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Ord> Ord for Stamp<T>

fn cmp(&self, other: &Stamp<T>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl<T: PartialEq> PartialEq for Stamp<T>

fn eq(&self, other: &Stamp<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T, R0> PartialEq<Stamp<T>> for StampReference<R0>

where R0: PartialEq<SmallVec<[T; 1]>>,

fn eq(&self, other: &Stamp<T>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: PartialOrd> PartialOrd for Stamp<T>

fn partial_cmp(&self, other: &Stamp<T>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'columnar, T, C0> Push<&'columnar Stamp<T>> for StampContainer<C0>

where C0: Push<&'columnar SmallVec<[T; 1]>>,

fn push(&mut self, item: &'columnar Stamp<T>)

Pushes an item onto self.

fn extend(&mut self, iter: impl IntoIterator<Item = T>)

Pushes elements of an iterator onto self.

impl<T, C0> Push<Stamp<T>> for StampContainer<C0>

where C0: Push<SmallVec<[T; 1]>>,

fn push(&mut self, item: Stamp<T>)

Pushes an item onto self.

fn extend(&mut self, iter: impl IntoIterator<Item = T>)

Pushes elements of an iterator onto self.

impl<T> Serialize for Stamp<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: PartialEq> StructuralPartialEq for Stamp<T>