Struct nonempty_collections::map::NEMap

pub struct NEMap<K, V, S = RandomState> {
    pub head_key: K,
    pub head_val: V,
    pub tail: HashMap<K, V, S>,
}

A non-empty, growable HashMap.

use nonempty_collections::nem;

let m = nem!["elves" => 3000, "orcs" => 10000];
assert_eq!(2, m.len().get());

Fields

head_key: K

The key of the ever-present element of the non-empty HashMap.

head_val: V

The value of the ever-present element of the non-empty HashMap.

tail: HashMap<K, V, S>

The remaining key-value pairs, perhaps empty.

Implementations

impl<K, V, S> NEMap<K, V, S>

pub fn capacity(&self) -> usize

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

pub fn hasher(&self) -> &S

Returns a reference to the map’s BuildHasher.

pub fn iter(&self) -> Iter<'_, K, V>

An iterator visiting all elements in arbitrary order. The iterator element type is (&'a K, &'a V).

pub fn iter_mut(&mut self) -> IterMut<'_, K, V>

An iterator visiting all elements in arbitrary order. The iterator element type is (&'a K, &'a mut V).

Panics

If you manually advance this iterator until empty and then call first, you’re in for a surprise.

pub fn keys(&self) -> Keys<'_, K, V>

An iterator visiting all keys in arbitrary order. The iterator element type is &'a K.

use nonempty_collections::*;

let m = nem!["Valmar" => "Vanyar", "Tirion" => "Noldor", "Alqualondë" => "Teleri"];
let mut v: NEVec<_> = m.keys().collect();
v.sort();
assert_eq!(nev![&"Alqualondë", &"Tirion", &"Valmar"], v);

pub fn len(&self) -> NonZeroUsize

Returns the number of elements in the map. Always 1 or more.

use nonempty_collections::nem;

let m = nem!["a" => 1, "b" => 2];
assert_eq!(2, m.len().get());

pub const fn is_empty(&self) -> bool

👎Deprecated since 0.1.0: A NEMap is never empty.

A NEMap is never empty.

pub fn values(&self) -> Values<'_, K, V>

An iterator visiting all values in arbitrary order. The iterator element type is &'a V.

use nonempty_collections::*;

let m = nem!["Valmar" => "Vanyar", "Tirion" => "Noldor", "Alqualondë" => "Teleri"];
let mut v: NEVec<_> = m.values().collect();
v.sort();
assert_eq!(nev![&"Noldor", &"Teleri", &"Vanyar"], v);

impl<K, V, S> NEMap<K, V, S>

where K: Eq + Hash, S: BuildHasher,

pub fn contains_key<Q>(&self, k: &Q) -> bool

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

Returns true if the map contains a value.

use nonempty_collections::nem;

let m = nem!["Jack" => 8];
assert!(m.contains_key("Jack"));
assert!(!m.contains_key("Colin"));

pub fn get<Q>(&self, k: &Q) -> Option<&V>

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

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s value type, but Hash and Eq on the borrowed form must match those for the key type.

use nonempty_collections::nem;

let m = nem!["silmarils" => 3];
assert_eq!(Some(&3), m.get("silmarils"));
assert_eq!(None, m.get("arkenstone"));

pub fn get_key_value<Q>(&self, k: &Q) -> Option<(&K, &V)>

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

Returns the key-value pair corresponding to the key.

The key may be any borrowed form of the map’s value type, but Hash and Eq on the borrowed form must match those for the key type.

use nonempty_collections::nem;

let m = nem!["silmarils" => 3];
assert_eq!(Some((&"silmarils", &3)), m.get_key_value("silmarils"));
assert_eq!(None, m.get_key_value("arkenstone"));

pub fn get_mut<Q>(&mut self, k: &Q) -> Option<&mut V>

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

Returns a reference to the value corresponding to the key.

The key may be any borrowed form of the map’s value type, but Hash and Eq on the borrowed form must match those for the key type.

use nonempty_collections::nem;

let mut m = nem!["silmarils" => 3];
let mut v = m.get_mut("silmarils").unwrap();

// And thus it came to pass that the Silmarils found their long homes:
// one in the airs of heaven, and one in the fires of the heart of the
// world, and one in the deep waters.
*v -= 3;

assert_eq!(Some(&0), m.get("silmarils"));

pub fn insert(&mut self, k: K, v: V) -> Option<V>

Insert a key-value pair into the map.

If the map did not have this present, None is returned.

If the map did have this key present, the value is updated, and the old value is returned. The key is not updated, though; this matters for types that can be == without being identical. See HashMap::insert for more.

use nonempty_collections::nem;

let mut m = nem!["Vilya" => "Elrond", "Nenya" => "Galadriel"];
assert_eq!(None, m.insert("Narya", "Cirdan"));

// The Ring of Fire was given to Gandalf upon his arrival in Middle Earth.
assert_eq!(Some("Cirdan"), m.insert("Narya", "Gandalf"));

pub fn new(k: K, v: V) -> NEMap<K, V>

Creates a new NEMap with a single element.

pub fn shrink_to_fit(&mut self)

Shrinks the capacity of the map as much as possible. It will drop down as much as possible while maintaining the internal rules and possibly leaving some space in accordance with the resize policy.

pub fn with_capacity(capacity: usize, k: K, v: V) -> NEMap<K, V>

Creates a new NEMap with a single element and specified capacity.

pub fn with_capacity_and_hasher( capacity: usize, hasher: S, k: K, v: V, ) -> NEMap<K, V, S>

See HashMap::with_capacity_and_hasher.

pub fn with_hasher(hasher: S, k: K, v: V) -> NEMap<K, V, S>

See HashMap::with_hasher.

Trait Implementations

impl<K: Clone, V: Clone, S: Clone> Clone for NEMap<K, V, S>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, S: Debug> Debug for NEMap<K, V, S>

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

Formats the value using the given formatter.

impl<'de, K, V, S> Deserialize<'de> for NEMap<K, V, S>

where K: Eq + Hash + Clone + Deserialize<'de>, V: Deserialize<'de>, S: Default + BuildHasher,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<K, V, S> From<NEMap<K, V, S>> for HashMap<K, V, S>

where K: Eq + Hash, S: BuildHasher,

fn from(m: NEMap<K, V, S>) -> Self

use nonempty_collections::nem;
use std::collections::HashMap;

let m: HashMap<&str, usize> = nem!["population" => 1000].into();
assert!(m.contains_key("population"));

impl<K, V, S> FromNonEmptyIterator<(K, V)> for NEMap<K, V, S>

where K: Eq + Hash, S: BuildHasher + Default,

use nonempty_collections::*;

let v = nev![('a', 1), ('b', 2), ('c', 3), ('a', 4)];
let m0: NEMap<_, _> = v.into_nonempty_iter().collect();
let m1: NEMap<_, _> = nem!['a' => 1, 'b' => 2, 'c' => 3];
assert_eq!(m0, m1);

fn from_nonempty_iter<I>(iter: I) -> Self

where I: IntoNonEmptyIterator<Item = (K, V)>,

Creates a value from a NonEmptyIterator.

impl<K, V, S> IntoNonEmptyIterator for NEMap<K, V, S>

type Item = (K, V)

The type of the elements being iterated over.

type IntoIter = Chain<Once<(K, V)>, IntoIter<K, V>>

Which kind of NonEmptyIterator are we turning this into?

fn into_nonempty_iter(self) -> Self::IntoIter

Creates a NonEmptyIterator from a value.

impl<K, V, S> PartialEq for NEMap<K, V, S>

where K: Eq + Hash, V: Eq, S: BuildHasher,

fn eq(&self, other: &Self) -> bool

This is an O(n) comparison of each key/value pair, one by one. Short-circuits if any comparison fails.

use nonempty_collections::*;

let m0 = nem!['a' => 1, 'b' => 2];
let m1 = nem!['b' => 2, 'a' => 1];
assert_eq!(m0, m1);

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, S> Serialize for NEMap<K, V, S>

where K: Eq + Hash + Clone + Serialize, V: Clone + Serialize, S: Clone + BuildHasher,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V, S> TryFrom<HashMap<K, V, S>> for NEMap<K, V, S>

where K: Eq + Hash + Clone, S: BuildHasher,

type Error = Error

The type returned in the event of a conversion error.

fn try_from(map: HashMap<K, V, S>) -> Result<Self, Self::Error>

Performs the conversion.

impl<K, V, S> Eq for NEMap<K, V, S>

where K: Eq + Hash, V: Eq, S: BuildHasher,