Struct Set

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

A default set of values.

Provides an API compatible with both HashSet and BTreeSet.

Implementations

impl<T> Set<T>

pub fn clear(&mut self)

Clears the Set, removing all elements.

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

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

Retains only the elements specified by the predicate.

In other words, remove all elements e for which f(&e) returns false. The elements are visited in unsorted (and unspecified) order.

pub fn len(&self) -> usize

Returns the number of elements in the Set.

pub fn is_empty(&self) -> bool

Returns true if the Set contains no elements.

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

Returns an iterator that yields the items in the Set.

impl<T> Set<T>

where T: Eq + Hash + Ord,

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

Reserves capacity for at least additional more elements to be inserted in the Set.

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

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

Returns true if the Set contains an element equal to the value.

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

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

Returns a reference to the element in the Set, if any, that is equal to the value.

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

Adds value to the Set.

Returns whether the value was newly inserted:

• Returns true if the set did not previously contain an equal value.
• Returns false otherwise and the entry is not updated.

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

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

If the set contains an element equal to the value, removes it from the Set and drops it.

Returns true if such an element was present, otherwise false.

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

where T: Borrow<Q>, Q: Hash + Ord + ?Sized,

Removes and returns the element in the Set, if any, that is equal to the value.

The value may be any borrowed form of the set’s element type, but the ordering on the borrowed form must match the ordering on the element type.

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

Adds a value to the Set, replacing the existing value, if any, that is equal to the given one. Returns the replaced value.

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

Returns true if self has no elements in common with other. This is equivalent to checking for an empty intersection.

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

Returns true if the Set is a subset of another, i.e., other contains at least all the values in self.

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

Returns true if the Set is a superset of another, i.e., self contains at least all the values in other.

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

Visits the values representing the difference, i.e., the values that are in self but not in other.

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

Visits the values representing the symmetric difference, i.e., the values that are in self or in other but not in both.

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

Visits the values representing the intersection, i.e., the values that are both in self and other.

When an equal element is present in self and other then the resulting Intersection may yield references to one or the other. This can be relevant if T contains fields which are not compared by its Eq implementation, and may hold different value between the two equal copies of T in the two sets.

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

Visits the values representing the union, i.e., all the values in self or other, without duplicates.

Trait Implementations

impl<'a, T> BitAnd for &'a Set<T>

where T: Eq + Hash + Ord + Clone + 'a,

type Output = Set<T>

The resulting type after applying the & operator.

fn bitand(self, rhs: &'a Set<T>) -> Set<T>

Performs the & operation.

impl<'a, T> BitOr for &'a Set<T>

where T: Eq + Hash + Ord + Clone + 'a,

type Output = Set<T>

The resulting type after applying the | operator.

fn bitor(self, rhs: &'a Set<T>) -> Set<T>

Performs the | operation.

impl<'a, T> BitXor for &'a Set<T>

where T: Eq + Hash + Ord + Clone + 'a,

type Output = Set<T>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: &'a Set<T>) -> Set<T>

Performs the ^ operation.

impl<T> Clone for Set<T>

where T: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for Set<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for Set<T>

fn default() -> Set<T>

Returns the “default value” for a type.

impl<'a, T> Deserialize<'a> for Set<T>

where T: Deserialize<'a> + Eq + Hash + Ord,

fn deserialize<D>( deserializer: D, ) -> Result<Set<T>, <D as Deserializer<'a>>::Error>

where D: Deserializer<'a>,

Deserialize this value from the given Serde deserializer.

impl<'a, T> Extend<&'a T> for Set<T>

where T: Hash + Eq + Ord + Copy + 'a,

fn extend<Iter>(&mut self, iter: Iter)

where Iter: IntoIterator<Item = &'a T>,

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> Extend<T> for Set<T>

where T: Hash + Eq + Ord,

fn extend<Iter>(&mut self, iter: Iter)

where Iter: IntoIterator<Item = T>,

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> FromIterator<T> for Set<T>

where T: Hash + Eq + Ord,

fn from_iter<I>(iter: I) -> Set<T>

where I: IntoIterator<Item = T>,

Creates a value from an iterator.

impl<'a, T> IntoIterator for &'a Set<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) -> <&'a Set<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> IntoIterator for Set<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = IntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Set<T> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<T> PartialEq for Set<T>

where T: Eq + Hash,

fn eq(&self, other: &Set<T>) -> 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> Serialize for Set<T>

where T: Serialize + Eq + Hash + Ord,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, T> Sub for &'a Set<T>

where T: Eq + Hash + Ord + Clone + 'a,

type Output = Set<T>

The resulting type after applying the - operator.

fn sub(self, rhs: &'a Set<T>) -> Set<T>

Performs the - operation.

impl<T> Eq for Set<T>

where T: Eq + Hash,