Struct erg_common::set::Set

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

Implementations

impl<T> Set<T>

pub fn new() -> Self

impl<T: Hash> Set<T>

pub fn with_capacity(capacity: usize) -> Self

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

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

pub fn to_vec(&self) -> Vec<T>

where T: Clone,

pub fn into_vec(self) -> Vec<T>

impl<T: Hash + Eq> Set<T>

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

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

pub fn get_by<Q>(&self, value: &Q, cmp: impl Fn(&Q, &Q) -> bool) -> Option<&T>

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

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

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

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

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

newly inserted: true, already present: false

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

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

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

pub fn extended<I: IntoIterator<Item = T>>(self, iter: I) -> Self

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

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

pub fn concat(self, other: Self) -> Self

pub fn retain(&mut self, f: impl FnMut(&T) -> bool)

remove all elements for which the predicate returns false

pub fn clear(&mut self)

pub fn take_all(&mut self) -> Self

pub fn inplace_map<F: FnMut(T) -> T>(&mut self, f: F)

impl<T: Hash + Eq + Clone> Set<T>

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

assert_eq!(set!{1, 2, 3}.union(&set!{2, 3, 4}), set!{1, 2, 3, 4});

pub fn union_iter<'a>( &'a self, other: &'a Set<T> ) -> impl Iterator<Item = &'a T>

pub fn union_from_iter<I: Iterator<Item = T>>(&self, iter: I) -> Set<T>

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

assert_eq!(set!{1, 2, 3}.intersection(&set!{2, 3, 4}), set!{2, 3});

pub fn intersec_iter<'a>( &'a self, other: &'a Set<T> ) -> impl Iterator<Item = &'a T>

pub fn intersec_from_iter<I: Iterator<Item = T>>(&self, iter: I) -> Set<T>

pub fn multi_intersection<I>(i: I) -> Set<T>

where I: Iterator<Item = Set<T>> + Clone,

assert_eq!(Set::multi_intersection([set!{1, 3}, set!{1, 2}].into_iter()), set!{1});
assert_eq!(Set::multi_intersection([set!{1, 3}, set!{1, 2}, set!{2}].into_iter()), set!{1, 2});
assert_eq!(Set::multi_intersection([set!{1, 3}, set!{1, 2}, set!{2, 3}].into_iter()), set!{1, 2, 3});

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

pub fn diff_iter<'a>(&'a self, other: &'a Set<T>) -> impl Iterator<Item = &'a T>

pub fn include(self, other: T) -> Set<T>

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

impl<T: Hash + Ord> Set<T>

pub fn max(&self) -> Option<&T>

pub fn min(&self) -> Option<&T>

impl<T: Hash + Display> Set<T>

pub fn folded_display(&self) -> String

Trait Implementations

impl<T: Clone> Clone for Set<T>

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

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

Formats the value using the given formatter.

impl<T> Default for Set<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Display> Display for Set<T>

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

Formats the value using the given formatter.

impl<T: Hash + Eq, const N: usize> From<[T; N]> for Set<T>

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

Converts to this type from the input type.

impl<T: Hash + Eq> From<Vec<T>> for Set<T>

fn from(vec: Vec<T>) -> Self

Converts to this type from the input type.

impl<T: Hash + Eq> FromIterator<T> for Set<T>

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

Creates a value from an iterator.

impl<T: Hash> Hash for Set<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: Hash> IntoIterator for Set<T>

type Item = T

The type of the elements being iterated over.

type IntoIter = <HashSet<T, BuildHasherDefault<FxHasher>> as IntoIterator>::IntoIter

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<T: Hash + Eq> PartialEq for Set<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Hash + Eq> Eq for Set<T>