Struct std::collections::hashset::HashSet

A hash-based set collection.

HashSet<T> is a wrapper around HashMap<T, ()>. Elements must satisfy the Hashable and Equatable protocols.

Example

use std::collections::HashSet;

let set = HashSet::new::<i32>();
defer set.free();

set.insert(1);
set.insert(2);
set.insert(3);

assert!(set.contains(&1));
assert!(set.contains(&2));
assert!(set.contains(&3));
Run this example

Methods

• fn new() -> HashSet<K, H>

  source

  Creates an empty set

  Will not allocate until the first element is inserted.

• fn with_capacity(capacity: usize) -> HashSet<K, H>

  source

  Creates an empty set that can store up to capacity items without reallocating.

• fn with_size(size: usize) -> HashSet<K, H>

  source

  Creates a set with a specific number of buckets.

  As HashSet uses amortized growth strategy, prefer to use with_capacity unless you want to strictly control the size of the underlying array.

• fn reserve(self: &mut HashSet<K, H>, additional: usize)

  source

  Reserves space for at least additional more elements to be inserted without reallocating.

  This follows the amortized growth strategy.

• fn rehash(self: &mut HashSet<K, H>, new_capacity: usize)

  source

  Resizes the underlying array to exactly the given new_capacity.

  Note that this could lead to poor performance if the resulting load factor is close to 1. Prefer to use reserve to grow the map and shrink_to_fit to shrink it.

  Panics if the new capacity is lower than the current size.

  Example

  use std::collections::HashSet;
  
  let set = HashSet::new::<i32>();
  defer set.free();
  
  set.insert(1);
  set.insert(2);
  set.insert(3);
  
  set.rehash(1); // panics
  Run this example

• fn shrink_to_fit(self: &mut HashSet<K, H>)

  source

  Reduces the size of underlying storage to fit the contained elements if needed.

• fn insert(self: &mut HashSet<K, H>, item: K) -> bool

  source

  Inserts a value into the set.

  Returns true if the value was newly inserted and false if the set already contained the value.

• fn remove(self: &mut HashSet<K, H>, item: &K) -> bool

  source

  Removes a value from the set.

  Returns true if the value was present in the set, false otherwise.

  Example

  use std::collections::HashSet;
  
  let set = HashSet::new::<i32>();
  defer set.free();
  
  set.insert(1);
  
  assert!(!set.remove(&2));
  assert!(set.remove(&1));
  assert!(!set.remove(&1));
  Run this example

• fn contains(self: &HashSet<K, H>, item: &K) -> bool

  source

  Retreives true if the set contains the given value, false otherwise.

  Example

  use std::collections::HashSet;
  
  let set = HashSet::new::<i32>();
  defer set.free();
  
  set.insert(1);
  
  assert!(set.contains(&1));
  assert!(!set.contains(&2));
  Run this example

• fn len(self: &HashSet<K, H>) -> usize

  source

  Retreives the number of elements in the set.

  Example

  use std::collections::HashSet;
  
  let set = HashSet::new::<i32>();
  defer set.free();
  
  set.insert(1);
  set.insert(2);
  set.insert(3);
  
  assert_eq!(set.len(), 3);
  Run this example

• fn is_empty(self: &HashSet<K, H>) -> bool

  source

  Returns true if the set is empty, false otherwise.

  Example

  use std::collections::HashSet;
  
  let set = HashSet::new::<i32>();
  defer set.free();
  
  assert!(set.is_empty());
  
  set.insert(1);
  
  assert!(!set.is_empty());
  Run this example

• fn clear(self: &mut HashSet<K, H>)

  source

  Clears the set, removing all values.

  This does not reduce the capacity of the heap (use shrink_to_fit afterwards or use move instead).

  Example

  use std::collections::HashSet;
  
  let set = HashSet::new::<i32>();
  defer set.free();
  
  set.insert(1);
  set.insert(2);
  set.insert(3);
  
  set.clear();
  
  assert!(set.is_empty());
  Run this example

• fn iter(self: &HashSet<K, H>) -> HashSetIterator<K>

  source

  Returns an iterator over the elements of this iterable.

  See Iterable for details.

• fn iter_ref(self: &HashSet<K, H>) -> HashSetRefIterator<K>

  source

  Returns an iterator over the pointers of the items of this iterable.

  See IterableRef for details.

• fn retain<F>(self: &mut HashSet<K, H>, func: F)

  F: Fn(&K) -> bool

  source

  Removes the elements not mathing the given predicate.

  Does not remove excess capacity, call shrink_to_fit afterwards, if this is desired.

  Example

  use std::collections::HashSet;
  
  let set = HashSet::new::<i32>();
  defer set.free();
  
  set.insert(1);
  set.insert(2);
  set.insert(3);
  
  set.retain(|x: &i32| -> bool { *x % 2 == 0 });
  
  assert!(!set.contains(&1));
  assert!(set.contains(&2));
  assert!(!set.contains(&3));
  Run this example

• fn free(self: &mut HashSet<K, H>)

  source

  Frees the memory backing the object.

• fn free_all(self: &mut HashSet<K, H>)

  source

  Helper for collections that own heap-allocated objects. This is used to be able to do defer col.free_all() without much boilerplate.

  Example

  use std::collections::HashSet;
  use std::string::StringBuf;
  use std::fmt::format;
  
  let v: HashSet<StringBuf> = HashSet::new();
  defer v.free_all();
  
  for i in 1..10 {
      v.insert("{} + {} = {}".format!(i, i, i + i).unwrap());
  }
  Run this example

• fn move(self: &mut HashSet<K, H>) -> HashSet<K, H>

  source

  Creates a copy of the object, leaving an inert object behind.

  See Movable for details.

• fn clone(self: &HashSet<K, H>) -> HashSet<K, H>

  source

  Returns a copy of the object.

• fn from_iter(iter: &mut I) -> HashSet<K, H>

  source

  Creates a hash map from an iterator of key-value pairs

  Example

  use std::collections::HashSet;
  let set: HashSet<i32> = HashSet::from_iter(&[1, 2, 3].iter());
  defer set.free();
  
  assert_eq!(set.len(), 3);
  assert!(set.contains(&1));
  assert!(set.contains(&2));
  assert!(set.contains(&3));
  Run this example

• fn extend(self: &mut HashSet<K, H>, iter: &mut I)

  source

  Inserts additional elements into the set from an iterator of key-value pairs.

• fn contains_borrowed(self: &HashSet<K, H>, key: B) -> bool

  source

  Checks if the value is present in the map by given borrowing of a key.

• fn remove_borrowed(self: &mut HashSet<K, H>, key: B) -> Option<K>

  source

  Removes the element from the set by given borrowing of a key.

  If the element with the given key was present in the set, it is removed and returned. Otherwise, Option::none() is returned.