Struct VecSet 

pub struct VecSet<T>(/* private fields */);

A set. It is a logic error for any value to change such that its equality under the Eq trait changes while it is in the set. To determine if two values are “the same”, Eq is used.

Implementations

impl<T> VecSet<T>

pub fn new() -> Self

Create a new VecSet.

pub fn with_capacity(capacity: usize) -> Self

Create a new VecSet with a given pre-allocated capacity. May allocate more than requested.

pub fn capacity(&self) -> usize

Get the allocated capacity of the set.

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

Get an iterator over the values as references.

pub fn len(&self) -> usize

Get the amount of values in the set.

pub fn is_empty(&self) -> bool

Check if the set is empty.

pub fn drain(&mut self) -> Drain<'_, T>

Empty the set and return an iterator over the cleared values.

pub fn retain<F>(&mut self, f: F)

where F: FnMut(&T) -> bool,

Remove all values that do not satisfy a given predicate.

pub fn clear(&mut self)

Remove all values.

pub fn reserve(&mut self, additional: usize)

Reserve additional space. May allocate more than requested.

Panics

Panics if the new allocation fails.

pub fn try_reserve(&mut self, additional: usize) -> Result<(), TryReserveError>

Like reserve, but returns a Result instead of panicking.

pub fn shrink_to_fit(&mut self)

Shrink the capacity of the set as much as possible. May keep more than precisely needed.

pub fn shrink_to(&mut self, min_capacity: usize)

Shrink the capacity of the set with a lower limit. May keep more than precisely needed.

impl<T: Eq> VecSet<T>

pub fn difference<'a>(&'a self, other: &'a VecSet<T>) -> Difference<'a, T>

Get an iterator over the set difference between two sets.

pub fn symmetric_difference<'a>( &'a self, other: &'a VecSet<T>, ) -> SymmetricDifference<'a, T>

Get an iterator over the symmetric set difference between two sets.

pub fn intersection<'a>(&'a self, other: &'a VecSet<T>) -> Intersection<'a, T>

Get an iterator over the intersection of two sets.

pub fn union<'a>(&'a self, other: &'a VecSet<T>) -> Union<'a, T>

Get an iterator over the union of two sets.

pub fn contains<Q>(&self, value: &Q) -> bool

where T: Borrow<Q>, Q: Eq + ?Sized,

Check if the set contains a given value.

pub fn get<Q>(&self, value: &Q) -> Option<&T>

where T: Borrow<Q>, Q: Eq + ?Sized,

Get a value stored in the set.

pub fn is_disjoint(&self, other: &VecSet<T>) -> bool

Check if two sets are disjoint.

pub fn is_subset(&self, other: &VecSet<T>) -> bool

Check if one set is a subset of another.

pub fn is_superset(&self, other: &VecSet<T>) -> bool

Check if one set is a superset of another.

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

Insert a value into the set. Returns true if the value was successfully inserted, and false if the value was already present.

pub fn replace(&mut self, value: T) -> Option<T>

Replace a value with a new, equal value. If the value is replaced successfully, the old value is returned.

pub fn remove<Q>(&mut self, value: &Q) -> bool

where T: Borrow<Q>, Q: Eq + ?Sized,

Remove a value from the set.

pub fn take<Q>(&mut self, value: &Q) -> Option<T>

where T: Borrow<Q>, Q: Eq + ?Sized,

Remove a value from the set. If the value is succesfully removed, it is returned.

impl<T: Eq> VecSet<T>

pub fn eq_ordered(&self, other: &Self)

Check two sets for equality while considering the order of values.

Trait Implementations

impl<T: Eq + Clone> BitAnd<&VecSet<T>> for &VecSet<T>

fn bitand(self, rhs: &VecSet<T>) -> Self::Output

Get the intersection of two sets as a new set.

type Output = VecSet<T>

The resulting type after applying the & operator.

impl<T: Eq + Clone> BitOr<&VecSet<T>> for &VecSet<T>

fn bitor(self, rhs: &VecSet<T>) -> Self::Output

Get the union of two sets as a new set.

type Output = VecSet<T>

The resulting type after applying the | operator.

impl<T: Eq + Clone> BitXor<&VecSet<T>> for &VecSet<T>

fn bitxor(self, rhs: &VecSet<T>) -> Self::Output

Get the symmetric set difference between two sets as a new set.

type Output = VecSet<T>

The resulting type after applying the ^ operator.

impl<T: Clone> Clone for VecSet<T>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for VecSet<T>

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

Formats the value using the given formatter.

impl<T> Default for VecSet<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'a, T: Eq + Copy> Extend<&'a T> for VecSet<T>

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T: Eq> Extend<T> for VecSet<T>

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

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

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

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

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

Reserves capacity in a collection for the given number of additional elements.

impl<T: Eq, const N: usize> From<[T; N]> for VecSet<T>

fn from(arr: [T; N]) -> Self

Converts to this type from the input type.

impl<T: Eq> FromIterator<T> for VecSet<T>

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

Creates a value from an iterator.

impl<'a, T> IntoIterator for &'a VecSet<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> IntoIterator for VecSet<T>

fn into_iter(self) -> Self::IntoIter

Get an iterator over the values.

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

impl<T: PartialEq + Ord> PartialEq for VecSet<T>

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T: Eq + Clone> Sub<&VecSet<T>> for &VecSet<T>

fn sub(self, rhs: &VecSet<T>) -> Self::Output

Get the set difference between two sets as a new set.

type Output = VecSet<T>

The resulting type after applying the - operator.

impl<T: Eq + Ord> Eq for VecSet<T>