Enum CollectionKind 

pub enum CollectionKind {
    Stream {
        bound: BoundKind,
        order: StreamOrder,
        retry: StreamRetry,
        element_type: DebugType,
    },
    Singleton {
        bound: SingletonBoundKind,
        element_type: DebugType,
    },
    Optional {
        bound: OptionalBoundKind,
        element_type: DebugType,
    },
    KeyedStream {
        bound: BoundKind,
        value_order: StreamOrder,
        value_retry: StreamRetry,
        key_type: DebugType,
        value_type: DebugType,
    },
    KeyedSingleton {
        bound: KeyedSingletonBoundKind,
        key_type: DebugType,
        value_type: DebugType,
    },
}

Variants

Stream

Fields

bound: BoundKind

order: StreamOrder

retry: StreamRetry

element_type: DebugType

Singleton

Fields

bound: SingletonBoundKind

element_type: DebugType

Optional

Fields

bound: OptionalBoundKind

element_type: DebugType

KeyedStream

Fields

bound: BoundKind

value_order: StreamOrder

value_retry: StreamRetry

key_type: DebugType

value_type: DebugType

KeyedSingleton

Fields

bound: KeyedSingletonBoundKind

key_type: DebugType

value_type: DebugType

Implementations

impl CollectionKind

pub fn is_bounded(&self) -> bool

pub fn is_strict(&self) -> bool

Returns whether this collection kind is already “strict” (TotalOrder + ExactlyOnce), meaning no non-determinism needs to be observed for mut closures.

pub fn root_repr_is_tombstoned_update_feed(&self) -> bool

Returns whether this collection kind, when materialized at a root (non-tick, non-atomic) location, is represented as a “tombstoned update feed”: a DFIR pipe whose elements are explicit update records that can express removal, rather than plain values.

• CollectionKind::Optional with OptionalBoundKind::Unbounded: the pipe carries Option<T> updates, where None is a tombstone recording that the optional became null. (Bounded and InitNone optionals never become null after having a value, so they are represented as plain T updates.)
• CollectionKind::KeyedSingleton with KeyedSingletonBoundKind::Unbounded: the pipe carries (K, Option<V>) updates, where (k, Some(v)) upserts an entry and (k, None) is a tombstone recording that key k was removed (e.g. garbage-collected by KeyedStream::reduce_watermark when the watermark advances). The other keyed bound kinds never remove keys (or are bounded), so they keep plain (K, V) entries.

This representation exists because a plain update feed cannot distinguish “no update” from “became absent” (#3181). It applies only at root locations: inside a tick (or atomic region fused into a tick’s loop), presence is re-derived every firing, so absence in a firing is already meaningful and plain values are used.

Producers of tombstoned feeds must emit an explicit tombstone for every removal (see the delta-emitting scan in the HydroNode::ReduceKeyedWatermark codegen); consumers hold the latest state across firings by applying updates (see DfirBuilder::batch). Generated code for keyed feeds requires K: Clone (and V: Clone), which the pre-existing whole-map re-emission already required.

pub fn strict_kind(&self) -> CollectionKind

Creates a “strict” version of this kind with TotalOrder and ExactlyOnce.

Trait Implementations

impl Clone for CollectionKind

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CollectionKind

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

Formats the value using the given formatter.

impl Eq for CollectionKind

impl PartialEq for CollectionKind

fn eq(&self, other: &Self) -> bool

Equality operator ==.

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

Inequality operator !=.

impl Serialize for CollectionKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for CollectionKind