An unsafe iterator over the entries of a HashTable in arbitrary order. The iterator element type is NonNull<T>.

This struct is created by the unsafe_iter method on HashTable.

This is used for implementations of iterators with "mixed" mutability on the iterated elements. For example, a mutable iterator for a map may return an immutable key alongside a mutable value, even though these are both stored inside the table.

If you have no idea what any of this means, you probably should be using IterMut instead, as it does not have any safety requirements.

Safety

In order to correctly use this iterator, it should be wrapped in a safe iterator struct with the appropriate PhantomData marker to indicate the correct variance.

For example, below is a simplified hash_map::IterMut implementation that correctly returns a covariant key, and an invariant value:

use core::marker::PhantomData;
use hashbrown::hash_table;

pub struct IterMut<'a, K, V> {
    inner: hash_table::UnsafeIter<'a, (K, V)>,
    // Covariant over keys, invariant over values
    marker: PhantomData<(&'a K, &'a mut V)>,
}
impl<'a, K, V> Iterator for IterMut<'a, K, V> {
    // Immutable keys, mutable values
    type Item = (&'a K, &'a mut V);

    fn next(&mut self) -> Option<Self::Item> {
        // SAFETY: The lifetime of the dereferenced pointer is derived from
        // the lifetime of its iterator, ensuring that it's always valid.
        // Additionally, we match the mutability in `self.marker` to ensure
        // the correct variance.
        let &mut (ref key, ref mut val) = unsafe { self.inner.next()?.as_mut() };
        Some((key, val))
    }
}