Struct SeqMap

pub struct SeqMap<K, V> { /* private fields */ }

A deterministic map that preserves insertion order.

Internally, it uses a HashMap for quick key lookups and a Vec to maintain the order of inserted key-value pairs.

Implementations

impl<K, V> SeqMap<K, V>

where K: Eq + Hash + Clone,

pub fn new() -> SeqMap<K, V>

Creates a new, empty SeqMap.

Examples

use seq_map::SeqMap;
let map: SeqMap<String, i32> = SeqMap::new();

pub fn insert(&mut self, key: K, value: V) -> Result<(), SeqMapError>

Inserts a key-value pair into the map.

Returns an error if the key already exists.

Errors

Returns SeqMapError::KeyAlreadyExists if the key is already present.

Examples

use seq_map::SeqMap;
let mut map = SeqMap::new();
map.insert("key".to_string(), 42).unwrap();
assert!(map.insert("key".to_string(), 43).is_err());

pub fn contains_key(&self, key: &K) -> bool

Checks if the map contains a key.

pub fn get_mut(&mut self, key: &K) -> Option<&mut V>

Returns a mutable reference to the value corresponding to the key.

Returns None if the key does not exist.

Examples

use seq_map::SeqMap;
let mut map = SeqMap::new();
map.insert("key".to_string(), 42).unwrap();
if let Some(value) = map.get_mut(&"key".to_string()) {
    *value = 100;
}
assert_eq!(map[&"key".to_string()], 100);

pub fn len(&self) -> usize

Returns the number of key-value pairs in the map.

Examples

use seq_map::SeqMap;
let mut map = SeqMap::new();
assert_eq!(map.len(), 0);
map.insert("key", 42).unwrap();
assert_eq!(map.len(), 1);

pub fn is_empty(&self) -> bool

Returns true if the map contains no elements.

Examples

use seq_map::SeqMap;
let map: SeqMap<String, i32> = SeqMap::new();
assert!(map.is_empty());

pub fn keys(&self) -> impl Iterator<Item = &K>

Returns an iterator over the keys of the map in insertion order.

Examples

use seq_map::SeqMap;
let mut map = SeqMap::new();
map.insert("a".to_string(), 1).unwrap();
map.insert("b".to_string(), 2).unwrap();
let keys: Vec<_> = map.keys().cloned().collect();
assert_eq!(keys, vec!["a", "b"]);

pub fn values(&self) -> impl Iterator<Item = &V>

Returns an iterator over the values of the map in insertion order.

Examples

use seq_map::SeqMap;
let mut map = SeqMap::new();
map.insert("a".to_string(), 1).unwrap();
map.insert("b".to_string(), 2).unwrap();
let values: Vec<_> = map.values().cloned().collect();
assert_eq!(values, vec![1, 2]);

pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V>

pub fn get_index(&self, key: &K) -> Option<usize>

pub fn iter(&self) -> impl Iterator<Item = (&K, &V)>

pub fn iter_mut(&mut self) -> impl Iterator<Item = (&K, &mut V)>

pub fn get(&self, key: &K) -> Option<&V>

Retrieves a reference to the value corresponding to the key.

This method performs a faster lookup using the internal HashMap.

For a slower but simpler lookup, see slow_get.

Examples

use seq_map::SeqMap;
let mut map = SeqMap::new();
map.insert("key".to_string(), 42).unwrap();
assert_eq!(map.get(&"key".to_string()), Some(&42));

pub fn clear(&mut self)

Removes all elements from the map

pub fn remove(&mut self, key: &K) -> Option<V>

Removes a key from the map, returning the value if it existed

pub fn drain(&mut self) -> impl Iterator<Item = (K, V)>

Removes all elements from the map and returns them as an iterator

impl<K, V> SeqMap<K, V>

where K: Eq + Hash + Clone,

pub fn into_keys(self) -> impl Iterator<Item = K>

pub fn into_values(self) -> impl Iterator<Item = V>

Trait Implementations

impl<K, V> Clone for SeqMap<K, V>

where K: Clone, V: Clone,

fn clone(&self) -> SeqMap<K, V>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K, V> Debug for SeqMap<K, V>

where K: Eq + Hash + Debug, V: Debug,

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

Formats the value using the given formatter.

impl<K, V> Default for SeqMap<K, V>

fn default() -> SeqMap<K, V>

Creates a new, empty SeqMap.

Examples

use seq_map::SeqMap;
let map: SeqMap<String, i32> = SeqMap::default();

impl<K, V> Display for SeqMap<K, V>

where K: Eq + Hash + Display, V: Display,

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

Formats the value using the given formatter.

impl<K, V> Extend<(K, V)> for SeqMap<K, V>

where K: Eq + Hash + Clone,

fn extend<T>(&mut self, iter: T)

where T: IntoIterator<Item = (K, V)>,

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<K, V> From<&[(K, V)]> for SeqMap<K, V>

where K: Eq + Hash + Clone, V: Clone,

fn from(slice: &[(K, V)]) -> SeqMap<K, V>

Creates a SeqMap from a slice of key-value pairs.

If duplicate keys are present in the slice, the first occurrence is kept, and subsequent duplicates are ignored.

Examples

use seq_map::SeqMap;
let pairs = vec![
    ("a".to_string(), 1),
    ("b".to_string(), 2),
];
let map: SeqMap<_, _> = SeqMap::from(&pairs[..]);
assert_eq!(map.len(), 2);

impl<K, V> FromIterator<(K, V)> for SeqMap<K, V>

where K: Hash + Eq + Clone, V: Clone,

Creates a SeqMap from an iterator of key-value pairs.

If duplicate keys are present in the iterator, the first occurrence is kept, and subsequent duplicates are silently ignored.

fn from_iter<T>(iter: T) -> SeqMap<K, V>

where T: IntoIterator<Item = (K, V)>,

Creates a value from an iterator.

impl<K, V> Hash for SeqMap<K, V>

where K: Hash, V: Hash,

fn hash<H>(&self, state: &mut H)

where H: Hasher,

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<K, V> Index<&K> for SeqMap<K, V>

where K: Eq + Hash + Clone, V: Clone,

fn index(&self, key: &K) -> &<SeqMap<K, V> as Index<&K>>::Output

Allows accessing values using the indexing syntax (map[&key]).

Panics

Panics if the key is not present in the map.

Examples

use seq_map::SeqMap;
let mut map = SeqMap::new();
map.insert("key".to_string(), 42).unwrap();
assert_eq!(map[&"key".to_string()], 42);

type Output = V

The returned type after indexing.

impl<'a, K, V> IntoIterator for &'a SeqMap<K, V>

where K: Eq + Hash + Clone,

fn into_iter(self) -> <&'a SeqMap<K, V> as IntoIterator>::IntoIter

Returns an iterator over references to the key-value pairs in insertion order.

This implementation allows you to iterate over references to the keys and values without consuming the SeqMap. It’s useful for scenarios where you want to inspect the contents of the map without modifying it.

Examples

Iterating Over References

use seq_map::SeqMap;

let mut map = SeqMap::new();
map.insert("a".to_string(), 1).unwrap();
map.insert("b".to_string(), 2).unwrap();
map.insert("c".to_string(), 3).unwrap();

for (key, value) in &map {
    println!("{}: {}", key, value);
}

Collecting into a Vector of References

use seq_map::SeqMap;

let mut map = SeqMap::new();
map.insert("x".to_string(), 100).unwrap();
map.insert("y".to_string(), 200).unwrap();

let entries: Vec<_> = (&map).into_iter().collect();
assert_eq!(
    entries,
    vec![
        (&"x".to_string(), &100),
        (&"y".to_string(), &200),
    ]
);

type Item = (&'a K, &'a V)

The type of the elements being iterated over.

type IntoIter = Map<Iter<'a, (K, V)>, fn(&'a (K, V)) -> (&'a K, &'a V)>

Which kind of iterator are we turning this into?

impl<'a, K, V> IntoIterator for &'a mut SeqMap<K, V>

where K: Eq + Hash + Clone,

type Item = (&'a K, &'a mut V)

The type of the elements being iterated over.

type IntoIter = Map<IterMut<'a, (K, V)>, fn(&'a mut (K, V)) -> (&'a K, &'a mut V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a mut SeqMap<K, V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V> IntoIterator for SeqMap<K, V>

where K: Eq + Hash + Clone,

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = IntoIter<(K, V)>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <SeqMap<K, V> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<K, V> PartialEq for SeqMap<K, V>

where K: Eq, V: Eq,

fn eq(&self, other: &SeqMap<K, V>) -> bool

Tests for self and other values to be equal, and is used by ==.

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<K, V> Eq for SeqMap<K, V>

where K: Eq, V: Eq,