Struct LinkedHashSet 

pub struct LinkedHashSet<T, S = RandomState> { /* private fields */ }

A hash set that preserves insertion order and exposes a VecDeque-like API with insert_back, insert_front, [pop_front], and [pop_back].

Implemented as a thin wrapper around LinkedHashMap<T, ()>.

Elements require only Hash + Eq. They do not need to be Clone or Copy — including heap-owning types such as String, Vec<T>, or Box<T>.

Ordering contract

insert_back and insert_front on an element that already exists are a no-op - the element keeps its current position. Use move_to_back / move_to_front to explicitly reorder an element.

Example

use linked_hash_table::LinkedHashSet;

let mut s = LinkedHashSet::new();
s.insert_back("a");
s.insert_back("b");
s.insert_back("c");
assert_eq!(s.pop_front(), Some("a"));
assert_eq!(s.pop_back(),  Some("c"));

Implementations

impl<T> LinkedHashSet<T>

pub fn new() -> Self

Creates an empty LinkedHashSet.

pub fn with_capacity(capacity: usize) -> Self

Creates an empty LinkedHashSet with the specified initial capacity.

impl<T, S> LinkedHashSet<T, S>

pub fn with_hasher(hash_builder: S) -> Self

Creates an empty LinkedHashSet using the supplied hasher builder.

pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> Self

Creates an empty LinkedHashSet with the given capacity and hasher.

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 capacity(&self) -> usize

Returns the number of elements the set can hold without reallocating.

pub fn hasher(&self) -> &S

Returns a reference to the set’s BuildHasher.

impl<T, S> LinkedHashSet<T, S>

where T: Hash + Eq, S: BuildHasher,

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

Inserts value at the back (most-recently-inserted end).

Returns true if the value was newly inserted. If the value already exists its position is preserved (no-op) and false is returned.

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

Inserts value at the front (least-recently-inserted end).

Returns true if the value was newly inserted. If the value already exists its position is preserved (no-op) and false is returned.

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

Alias for insert_back - matches the HashSet::insert signature.

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

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

Returns true if the set contains value.

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

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

Returns a reference to the element in the set that equals value, or None if it is not present.

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

Returns a reference to the front (oldest) element, or None if the set is empty.

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

Returns a reference to the back (most recently inserted) element, or None if the set is empty.

pub fn pop_front(&mut self) -> Option<T>

Removes and returns the front (oldest) element, or None.

pub fn pop_back(&mut self) -> Option<T>

Removes and returns the back (newest) element, or None.

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

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

Removes value from the set. Returns true if the element was present.

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

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

Removes the element equal to value and returns it, if present.

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

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

Retains only the elements for which f returns true. Elements are visited in insertion order (front → back).

pub fn clear(&mut self)

Removes all elements from the set.

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

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

Moves value to the back of the ordering. Returns true if the element was found.

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

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

Moves value to the front of the ordering. Returns true if the element was found.

pub fn drain(&mut self) -> SetDrain<'_, T>

Removes all elements in insertion order, returning them via an iterator. The set is empty after this call (even if the iterator is dropped before it is fully consumed).

pub fn is_subset<S2: BuildHasher>(&self, other: &LinkedHashSet<T, S2>) -> bool

Returns true if every element of self is also contained in other.

pub fn is_superset<S2: BuildHasher>(&self, other: &LinkedHashSet<T, S2>) -> bool

Returns true if every element of other is also contained in self.

pub fn is_disjoint<S2: BuildHasher>(&self, other: &LinkedHashSet<T, S2>) -> bool

Returns true if self and other share no elements.

impl<T, S> LinkedHashSet<T, S>

pub fn iter<'a>(&'a self) -> SetIter<'a, T>

Returns an iterator over elements in insertion order.

Trait Implementations

impl<T: Clone + Hash + Eq, S: BuildHasher + Clone> Clone for LinkedHashSet<T, S>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Debug, S> Debug for LinkedHashSet<T, S>

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

Formats the value using the given formatter.

impl<T> Default for LinkedHashSet<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: Hash + Eq, S: BuildHasher> Extend<T> for LinkedHashSet<T, S>

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

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

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

Creates a value from an iterator.

impl<'a, T, S> IntoIterator for &'a LinkedHashSet<T, S>

Shared-reference iterator: yields &T in insertion order.

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = SetIter<'a, T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> SetIter<'a, T>

Creates an iterator from a value.

impl<T, S> IntoIterator for LinkedHashSet<T, S>

Consuming iterator: yields all elements in insertion order.

type Item = T

The type of the elements being iterated over.

type IntoIter = SetIntoIter<T>

Which kind of iterator are we turning this into?

fn into_iter(self) -> SetIntoIter<T>

Creates an iterator from a value.

impl<T: PartialEq, S1, S2> PartialEq<LinkedHashSet<T, S2>> for LinkedHashSet<T, S1>

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

Two sets are equal only when they contain the same elements in the same order.

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: PartialEq + Eq, S> Eq for LinkedHashSet<T, S>