Struct VecSet 

pub struct VecSet<E: Element> { /* private fields */ }

Implementations

impl<E: Element> VecSet<E>

pub fn new() -> Self

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

Trait Implementations

impl<'a, E: Element> BitAnd for &'a VecSet<E>

type Output = VecSet<E>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a VecSet<E>) -> Self::Output

Performs the & operation.

impl<'a, E: Element> BitAndAssign<&'a E> for VecSet<E>

fn bitand_assign(&mut self, rhs: &E)

Performs the &= operation.

impl<'a, E: Element> BitAndAssign<&'a VecSet<E>> for VecSet<E>

fn bitand_assign(&mut self, rhs: &VecSet<E>)

Performs the &= operation.

impl<'a, E: Element> BitOr<&'a VecSet<E>> for &VecSet<E>

type Output = VecSet<E>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a VecSet<E>) -> VecSet<E>

Performs the | operation.

impl<'a, E: Element> BitOrAssign<&'a E> for VecSet<E>

fn bitor_assign(&mut self, rhs: &E)

Performs the |= operation.

impl<'a, E: Element> BitOrAssign<&'a VecSet<E>> for VecSet<E>

fn bitor_assign(&mut self, rhs: &VecSet<E>)

Performs the |= operation.

impl<'a, E: Element> BitXor<&'a VecSet<E>> for &VecSet<E>

type Output = VecSet<E>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a VecSet<E>) -> VecSet<E>

Performs the ^ operation.

impl<'a, E: Element> BitXorAssign<&'a E> for VecSet<E>

fn bitxor_assign(&mut self, rhs: &E)

Performs the ^= operation.

impl<'a, E: Element> BitXorAssign<&'a VecSet<E>> for VecSet<E>

fn bitxor_assign(&mut self, rhs: &VecSet<E>)

Performs the ^= operation.

impl<E: Element> BitXorAssign for VecSet<E>

fn bitxor_assign(&mut self, rhs: VecSet<E>)

Performs the ^= operation.

impl<E: Clone + Element> Clone for VecSet<E>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug + Element> Debug for VecSet<E>

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

Formats the value using the given formatter.

impl<E: Element> Default for VecSet<E>

fn default() -> Self

Returns the “default value” for a type.

impl<E: Element, const N: usize> From<[E; N]> for VecSet<E>

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

Converts to this type from the input type.

impl<E: Element> FromIterator<E> for VecSet<E>

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

Creates a value from an iterator.

impl<'a, E: Element> IntoIterator for &'a VecSet<E>

type Item = &'a E

The type of the elements being iterated over.

type IntoIter = Iter<'a, E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, E: Element + 'a> Set<'a> for VecSet<E>

type Element = E

type Iter = Iter<'a, E>

type Difference = Difference<'a, E>

type Intersection = Intersection<'a, E>

type SymmetricDifference = SymmetricDifference<'a, E>

type Union = Union<'a, E>

fn new() -> Self

fn capacity(&self) -> usize

fn clear(&mut self)

fn contains(&self, value: &E) -> bool

fn difference(&'a self, other: &'a Self) -> Self::Difference

Returns an iterator of elements representing the difference between this set and another, i.e., the elements that are in self but not in other.

fn difference_ref(&'a self, other: &'a Self) -> Self::Difference

fn insert(&mut self, value: E)

fn intersection(&'a self, other: &'a Self) -> Self::Intersection

fn is_empty(&self) -> bool

fn iter(&'a self) -> Self::Iter

fn len(&self) -> usize

fn remove(&mut self, value: &E)

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

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

fn symmetric_difference(&'a self, other: &'a Self) -> Self::SymmetricDifference

fn symmetric_difference_update(&mut self, rhs: &Self)

fn union(&'a self, other: &'a Self) -> Self::Union

fn union_update(&mut self, rhs: &Self)

fn with_capacity(capacity: usize) -> Self

fn intersection_update(&mut self, rhs: &Self)

fn intersection_item_update(&mut self, value: &Self::Element)

fn symmetric_difference_item_update(&mut self, value: &Self::Element)

fn union_item_update(&mut self, value: &Self::Element)

fn bitand_assign_set(&mut self, rhs: &Self)

fn bitand_assign_item(&mut self, rhs: &Self::Element)

fn bitor_assign_set(&mut self, rhs: &Self)

fn bitor_assign_item(&mut self, rhs: &Self::Element)

fn bitxor_assign_set(&mut self, rhs: &Self)

fn bitxor_assign_item(&mut self, rhs: &Self::Element)

fn sub_assign_set(&mut self, rhs: &Self)

fn sub_assign_item(&mut self, rhs: &Self::Element)

impl<'a, E: Element> Sub<&'a VecSet<E>> for &VecSet<E>

type Output = VecSet<E>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a VecSet<E>) -> VecSet<E>

Performs the - operation.

impl<'a, E: Element> SubAssign<&'a E> for VecSet<E>

fn sub_assign(&mut self, rhs: &E)

Performs the -= operation.

impl<'a, E: Element> SubAssign<&'a VecSet<E>> for VecSet<E>

fn sub_assign(&mut self, rhs: &VecSet<E>)

Performs the -= operation.