Struct HashSet

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

Implementations

impl<T> HashSet<T>

where T: Clone + Default + Debug + Hash + Eq + PartialEq,

pub fn new() -> Self

Constructor for an empty set with a default capacity of 2 because everyone deserves a friend.

pub fn new_with_capacity(size: usize) -> Self

Constructor for an empty set with a given capacity.

pub fn size(&self) -> usize

Returns the number of elements in the set.

pub fn is_empty(&self) -> bool

Returns true if the set is either empty or contains only empty slots and deleted entries.

pub fn put(&mut self, elem: T)

Adds an item to the set.

pub fn remove(&mut self, elem: T) -> Option<T>

Removes an item from the set.

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

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

Returns true if the set contains the referenced element.

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

Returns an iterator over references to all elements that appear in either self or other as a set-theoretic union.

pub fn extend(&mut self, other: Self)

A mutating version of union() that consumes other to add all of its elements to self.

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

Returns an iterator over references to elements that appear in both self and other as a set-theoretic intersection.

pub fn retain_all(&mut self, other: &Self)

Mutates self such that self only keeps elements that are also in other. Different from the function retain which takes a closure to only retain elements according to the predicate.

NOTE: This function could also appropriately be called “intersect”, but that was too close to the non-mutating version of this function called “intersection”.

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

Returns an iterator over references to elements that are present in self but not in other as a set-theoretic asymmetric difference or relative complement. This operation is asymmetric: interchanging self and other generally produces different results.

pub fn unique<'a>(&'a self, other: &'a Self) -> Unique<'a, T>

Returns an iterator over references to elements that are present in exactly one of the two sets as a set-theoretic symmetric difference. This operation is symmetric: interchanging self and other yields the same result.

Trait Implementations

impl<T> Default for HashSet<T>

where T: Clone + Default + Debug + Hash + Eq + PartialEq,

fn default() -> Self

Returns the “default value” for a type.