Struct SeqMap

pub struct SeqMap<K, V>
where
    K: Eq + Hash + Clone,
{ /* 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() -> Self

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 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 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));

Trait Implementations

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

where K: Eq + Hash + Clone + 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> Debug for SeqMap<K, V>

where K: Eq + Hash + Clone + Debug,

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

Formats the value using the given formatter.

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

where K: Eq + Hash + Clone,

fn default() -> Self

Creates a new, empty SeqMap.

Examples

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

impl<K, V> From<&[(K, V)]> for SeqMap<K, V>

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

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

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

where K: Eq + Hash + Clone,

fn index(&self, key: &K) -> &Self::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) -> Self::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<K, V: PartialEq> PartialEq for SeqMap<K, V>

where K: Eq + Hash + Clone + PartialEq,

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

where K: Eq + Hash + Clone + Eq,

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

where K: Eq + Hash + Clone,