Struct Set

pub struct Set<T: Copy + Eq + Hash> { /* private fields */ }

A set that is a HashSet when it has many elements, but is just an array for small set sizes.

As with the HashSet type, a Set requires that the elements implement the Eq and Hash traits. This can frequently be achieved by using #[derive(PartialEq, Eq, Hash)]. In addition, Set requires that the elements implement the Copy trait, and really they should be pretty small, since Set always stores room for CAPACITY elements.

Implementations

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

pub fn new() -> Set<T>

Creates an empty set..

pub fn with_capacity(cap: usize) -> Set<T>

Creates an empty set with the specified capacity.

pub fn len(&self) -> usize

Returns the number of elements in the set.

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

Reserves capacity for at least additional more elements to be inserted in the set. The collection may reserve more space to avoid frequent reallocations.

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

Adds a value to the set.

If the set did not have this value present, true is returned.

If the set did have this value present, false is returned.

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

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

Removes an element, and returns true if that element was present.

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

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

Returns true if the set contains a value.

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

Returns an iterator over the set.

pub fn drain(&mut self) -> IntoIter<T>

Clears the set, returning all elements in an iterator.

Trait Implementations

impl<'a, 'b, T: Eq + Hash + Copy> BitOr<&'b Set<T>> for &'a Set<T>

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

Returns the union of self and rhs as a new Set<T>.

Examples

use david_set::Set;

let a: Set<u32> = vec![1, 2, 3].into_iter().collect();
let b: Set<u32> = vec![3, 4, 5].into_iter().collect();

let set = &a | &b;

let mut i = 0;
let expected = [1, 2, 3, 4, 5];
for x in &set {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

type Output = Set<T>

The resulting type after applying the | operator.

impl<T: Clone + Copy + Eq + Hash> 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 + Copy + Eq + Hash> Debug for Set<T>

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

Formats the value using the given formatter.

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

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

Adds a bunch of elements to the set

Examples

use david_set::Set;

let mut a: Set<u32> = vec![1, 2, 3].into_iter().collect();
a.extend(vec![3, 4, 5]);

let mut i = 0;
let expected = [1, 2, 3, 4, 5];
for x in &a {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

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: Hash + Copy + Eq> FromIterator<T> for Set<T>

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

Creates a value from an iterator.

impl<'a, T: Eq + Hash + Copy> 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) -> Iter<'a, T>

Creates an iterator from a value.

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

fn into_iter(self) -> IntoIter<T>

Creates a consuming iterator, that is, one that moves each value out of the set in arbitrary order. The set cannot be used after calling this.

Examples

use david_set::Set;
let mut set: Set<u32> = Set::new();
set.insert(2);
set.insert(5);

// Not possible to collect to a Vec<String> with a regular `.iter()`.
let v: Vec<_> = set.into_iter().collect();

// Will print in an arbitrary order.
for x in &v {
    println!("{}", x);
}

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<'a, 'b, T: Eq + Hash + Copy> Sub<&'b Set<T>> for &'a Set<T>

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

Returns the difference of self and rhs as a new Set<T>.

Examples

use david_set::Set;

let a: Set<u32> = vec![1, 2, 3].into_iter().collect();
let b: Set<u32> = vec![3, 4, 5].into_iter().collect();

let set = &a - &b;

let mut i = 0;
let expected = [1, 2];
for x in &set {
    assert!(expected.contains(x));
    i += 1;
}
assert_eq!(i, expected.len());

type Output = Set<T>

The resulting type after applying the - operator.