Enum SmallCopySet 

pub enum SmallCopySet<T: Copy + Debug + Hash + Eq> {
    Empty,
    One([T; 1]),
    Two([T; 2]),
    Three([T; 3]),
}

A small set of up to 3 Copy elements, used as an optimization in RerunCondition. The entire set can be Copyed because of this requirement.

Set properties maintained using union, which deduplicates values.

Variants

Empty

One([T; 1])

Two([T; 2])

Three([T; 3])

Implementations

impl<T: Copy + Debug + Hash + Eq> SmallCopySet<T>

fn empty() -> Self

fn new(first: T) -> Self

fn union(self, other: Self) -> Option<Self>

Computes the union of two lists. Duplicates are removed.

Since the set can hold at most 3 elements, returns None if the resulting set cannot be represented.

In the context of RerunCondition, this means we fall back to rerunning unconditionally. This can be beneficial, since at some point, tracking all the conditions under which a query has to be rerun becomes slower than just rerunning unconditionally. This is especially so, since as long as rerun conditions are tracked, we keep executing the current query. As soon as we cannot track anymore, and unconditionally rerun, we also abort the current query. By at some point opting to abort early, we may save a lot of time skipping further work that will have to likely be redone anyway.

note that not all cases are handled. you can union two lists of two elements with equal elements, and still get none back. checking for all cases is more work than just rerunning in some cases.

Trait Implementations

impl<T: Copy + Debug + Hash + Eq> AsRef<[T]> for SmallCopySet<T>

fn as_ref(&self) -> &[T]

Converts this type into a shared reference of the (usually inferred) input type.

impl<T: Clone + Copy + Debug + Hash + Eq> Clone for SmallCopySet<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Copy + Copy + Debug + Hash + Eq> Copy for SmallCopySet<T>

impl<T: Debug + Copy + Debug + Hash + Eq> Debug for SmallCopySet<T>

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

Formats the value using the given formatter.

impl<T: Eq + Copy + Debug + Hash + Eq> Eq for SmallCopySet<T>

impl<T: Hash + Copy + Debug + Hash + Eq> Hash for SmallCopySet<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<T: PartialEq + Copy + Debug + Hash + Eq> PartialEq for SmallCopySet<T>

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

Equality operator ==.

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

Inequality operator !=.

impl<T: Copy + Debug + Hash + Eq> StableHash for SmallCopySet<T>

where [T; 1]: StableHash, [T; 2]: StableHash, [T; 3]: StableHash,

fn stable_hash<__Hcx: StableHashCtxt>( &self, __hcx: &mut __Hcx, __hasher: &mut StableHasher, )

impl<T: PartialEq + Copy + Debug + Hash + Eq> StructuralPartialEq for SmallCopySet<T>

impl<T, I> TypeFoldable<I> for SmallCopySet<T>

where I: Interner, T: TypeFoldable<I> + Copy + Debug + Hash + Eq, [T; 1]: TypeFoldable<I>, [T; 2]: TypeFoldable<I>, [T; 3]: TypeFoldable<I>,

fn try_fold_with<__F: FallibleTypeFolder<I>>( self, __folder: &mut __F, ) -> Result<Self, __F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<__F: TypeFolder<I>>(self, __folder: &mut __F) -> Self

The entry point for folding. To fold a value t with a folder f call: t.fold_with(f).

impl<T: Copy + Debug + Hash + Eq, I> TypeVisitable<I> for SmallCopySet<T>

where I: Interner, [T; 1]: TypeVisitable<I>, [T; 2]: TypeVisitable<I>, [T; 3]: TypeVisitable<I>,

fn visit_with<__V: TypeVisitor<I>>(&self, __visitor: &mut __V) -> __V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.