Struct NEMap 

pub struct NEMap<K, V, S = RandomState> { /* private fields */ }

A non-empty, growable HashMap.

use nonempty_collections::nem;

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

Implementations

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

where K: Eq + Hash,

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

Creates a new NEMap with a single element.

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

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

use std::num::*;

use nonempty_collections::*;
let map = NEMap::with_capacity(NonZeroUsize::MIN, 1, 1);
assert_eq!(nem! { 1 => 1 }, map);
assert!(map.capacity().get() >= 1);

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

pub fn try_from_map(map: HashMap<K, V, S>) -> Option<Self>

Attempt a conversion from HashMap, consuming the given HashMap. Will return None if the HashMap is empty.

use std::collections::*;

use nonempty_collections::*;

let mut map = HashMap::new();
map.extend([("a", 1), ("b", 2)]);
assert_eq!(Some(nem! {"a" => 1, "b" => 2}), NEMap::try_from_map(map));
let map: HashMap<(), ()> = HashMap::new();
assert_eq!(None, NEMap::try_from_map(map));

pub fn capacity(&self) -> NonZeroUsize

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>

Returns a regular iterator over the entries in this non-empty map.

For a NonEmptyIterator see Self::nonempty_iter().

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

Returns a regular mutable iterator over the entries in this non-empty map.

For a NonEmptyIterator see Self::nonempty_iter_mut().

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

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

pub fn nonempty_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 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_and_hasher( capacity: NonZeroUsize, 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, V, S> AsMut<HashMap<K, V, S>> for NEMap<K, V, S>

fn as_mut(&mut self) -> &mut HashMap<K, V, S>

Converts this type into a mutable reference of the (usually inferred) input type.

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

fn as_ref(&self) -> &HashMap<K, V, S>

Converts this type into a shared reference of the (usually inferred) input type.

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

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug, V: Debug, S> 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> Extend<(K, V)> for NEMap<K, V>

where K: Eq + Hash,

fn extend<I: IntoIterator<Item = (K, V)>>(&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<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' => 4, '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<'a, K, V, S> IntoIterator for &'a NEMap<K, V, S>

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

The type of the elements being iterated over.

type IntoIter = Iter<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

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

The type of the elements being iterated over.

type IntoIter = IterMut<'a, K, V>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

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

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) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, K, V, S> IntoNonEmptyIterator for &'a NEMap<K, V, S>

type IntoNEIter = Iter<'a, K, V>

Which kind of NonEmptyIterator are we turning this into?

fn into_nonempty_iter(self) -> Self::IntoNEIter

Creates a NonEmptyIterator from a value.

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

type IntoNEIter = IntoIter<K, V>

Which kind of NonEmptyIterator are we turning this into?

fn into_nonempty_iter(self) -> Self::IntoNEIter

Creates a NonEmptyIterator from a value.

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

where K: Eq + Hash, V: PartialEq, 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> Singleton for NEMap<K, V>

where K: Eq + Hash,

fn singleton((k, v): Self::Item) -> Self

use nonempty_collections::{NEMap, Singleton, nem};

let m = NEMap::singleton(('a', 1));
assert_eq!(nem!['a' => 1], m);

type Item = (K, V)

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

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

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,