edg-l/edlang
1
1
Fork 0
mirror of https://github.com/edg-l/edlang.git synced 2024-11-09 17:48:24 +00:00
Code Issues Packages Projects Releases Wiki Activity
edlang/hashbrown/hash_map/struct.HashMap.html
edg-l df146223dd deploy: b3bd34a9bb
2024-07-26 09:42:18 +00:00

1387 lines
206 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="A hash map implemented with quadratic probing and SIMD lookup."><title>HashMap in hashbrown::hash_map - Rust</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-46f98efaafac5295.ttf.woff2,FiraSans-Regular-018c141bf0843ffd.woff2,FiraSans-Medium-8f9a781e4970d388.woff2,SourceCodePro-Regular-562dcc5011b6de7d.ttf.woff2,SourceCodePro-Semibold-d899c5a5c4aeb14a.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2" crossorigin href="../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../static.files/normalize-76eba96aa4d2e634.css"><link rel="stylesheet" href="../../static.files/rustdoc-dd39b87e5fcfba68.css"><meta name="rustdoc-vars" data-root-path="../../" data-static-root-path="../../static.files/" data-current-crate="hashbrown" data-themes="" data-resource-suffix="" data-rustdoc-version="1.80.0 (051478957 2024-07-21)" data-channel="1.80.0" data-search-js="search-d52510db62a78183.js" data-settings-js="settings-4313503d2e1961c2.js" ><script src="../../static.files/storage-118b08c4c78b968e.js"></script><script defer src="sidebar-items.js"></script><script defer src="../../static.files/main-20a3ad099b048cf2.js"></script><noscript><link rel="stylesheet" href="../../static.files/noscript-df360f571f6edeae.css"></noscript><link rel="alternate icon" type="image/png" href="../../static.files/favicon-32x32-422f7d1d52889060.png"><link rel="icon" type="image/svg+xml" href="../../static.files/favicon-2c020d218678b618.svg"></head><body class="rustdoc struct"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="mobile-topbar"><button class="sidebar-menu-toggle" title="show sidebar"></button></nav><nav class="sidebar"><div class="sidebar-crate"><h2><a href="../../hashbrown/index.html">hashbrown</a><span class="version">0.14.5</span></h2></div><h2 class="location"><a href="#">HashMap</a></h2><div class="sidebar-elems"><section><h3><a href="#implementations">Methods</a></h3><ul class="block method"><li><a href="#method.allocator">allocator</a></li><li><a href="#method.capacity">capacity</a></li><li><a href="#method.clear">clear</a></li><li><a href="#method.contains_key">contains_key</a></li><li><a href="#method.drain">drain</a></li><li><a href="#method.entry">entry</a></li><li><a href="#method.entry_ref">entry_ref</a></li><li><a href="#method.extract_if">extract_if</a></li><li><a href="#method.get">get</a></li><li><a href="#method.get_key_value">get_key_value</a></li><li><a href="#method.get_key_value_mut">get_key_value_mut</a></li><li><a href="#method.get_many_key_value_mut">get_many_key_value_mut</a></li><li><a href="#method.get_many_key_value_unchecked_mut">get_many_key_value_unchecked_mut</a></li><li><a href="#method.get_many_mut">get_many_mut</a></li><li><a href="#method.get_many_unchecked_mut">get_many_unchecked_mut</a></li><li><a href="#method.get_mut">get_mut</a></li><li><a href="#method.hasher">hasher</a></li><li><a href="#method.insert">insert</a></li><li><a href="#method.insert_unique_unchecked">insert_unique_unchecked</a></li><li><a href="#method.into_keys">into_keys</a></li><li><a href="#method.into_values">into_values</a></li><li><a href="#method.is_empty">is_empty</a></li><li><a href="#method.iter">iter</a></li><li><a href="#method.iter_mut">iter_mut</a></li><li><a href="#method.keys">keys</a></li><li><a href="#method.len">len</a></li><li><a href="#method.raw_entry">raw_entry</a></li><li><a href="#method.raw_entry_mut">raw_entry_mut</a></li><li><a href="#method.raw_table">raw_table</a></li><li><a href="#method.raw_table_mut">raw_table_mut</a></li><li><a href="#method.remove">remove</a></li><li><a href="#method.remove_entry">remove_entry</a></li><li><a href="#method.reserve">reserve</a></li><li><a href="#method.retain">retain</a></li><li><a href="#method.shrink_to">shrink_to</a></li><li><a href="#method.shrink_to_fit">shrink_to_fit</a></li><li><a href="#method.try_insert">try_insert</a></li><li><a href="#method.try_reserve">try_reserve</a></li><li><a href="#method.values">values</a></li><li><a href="#method.values_mut">values_mut</a></li><li><a href="#method.with_capacity_and_hasher">with_capacity_and_hasher</a></li><li><a href="#method.with_capacity_and_hasher_in">with_capacity_and_hasher_in</a></li><li><a href="#method.with_hasher">with_hasher</a></li><li><a href="#method.with_hasher_in">with_hasher_in</a></li></ul><h3><a href="#trait-implementations">Trait Implementations</a></h3><ul class="block trait-implementation"><li><a href="#impl-Clone-for-HashMap%3CK,+V,+S,+A%3E">Clone</a></li><li><a href="#impl-Debug-for-HashMap%3CK,+V,+S,+A%3E">Debug</a></li><li><a href="#impl-Default-for-HashMap%3CK,+V,+S,+A%3E">Default</a></li><li><a href="#impl-Eq-for-HashMap%3CK,+V,+S,+A%3E">Eq</a></li><li><a href="#impl-Extend%3C%26(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E">Extend&lt;&amp;&#x27;a (K, V)&gt;</a></li><li><a href="#impl-Extend%3C(%26K,+%26V)%3E-for-HashMap%3CK,+V,+S,+A%3E">Extend&lt;(&amp;&#x27;a K, &amp;&#x27;a V)&gt;</a></li><li><a href="#impl-Extend%3C(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E">Extend&lt;(K, V)&gt;</a></li><li><a href="#impl-From%3CHashMap%3CT,+(),+S,+A%3E%3E-for-HashSet%3CT,+S,+A%3E">From&lt;HashMap&lt;T, (), S, A&gt;&gt;</a></li><li><a href="#impl-FromIterator%3C(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E">FromIterator&lt;(K, V)&gt;</a></li><li><a href="#impl-Index%3C%26Q%3E-for-HashMap%3CK,+V,+S,+A%3E">Index&lt;&amp;Q&gt;</a></li><li><a href="#impl-IntoIterator-for-%26HashMap%3CK,+V,+S,+A%3E">IntoIterator</a></li><li><a href="#impl-IntoIterator-for-%26mut+HashMap%3CK,+V,+S,+A%3E">IntoIterator</a></li><li><a href="#impl-IntoIterator-for-HashMap%3CK,+V,+S,+A%3E">IntoIterator</a></li><li><a href="#impl-PartialEq-for-HashMap%3CK,+V,+S,+A%3E">PartialEq</a></li></ul><h3><a href="#synthetic-implementations">Auto Trait Implementations</a></h3><ul class="block synthetic-implementation"><li><a href="#impl-Freeze-for-HashMap%3CK,+V,+S,+A%3E">Freeze</a></li><li><a href="#impl-RefUnwindSafe-for-HashMap%3CK,+V,+S,+A%3E">RefUnwindSafe</a></li><li><a href="#impl-Send-for-HashMap%3CK,+V,+S,+A%3E">Send</a></li><li><a href="#impl-Sync-for-HashMap%3CK,+V,+S,+A%3E">Sync</a></li><li><a href="#impl-Unpin-for-HashMap%3CK,+V,+S,+A%3E">Unpin</a></li><li><a href="#impl-UnwindSafe-for-HashMap%3CK,+V,+S,+A%3E">UnwindSafe</a></li></ul><h3><a href="#blanket-implementations">Blanket Implementations</a></h3><ul class="block blanket-implementation"><li><a href="#impl-Any-for-T">Any</a></li><li><a href="#impl-Borrow%3CT%3E-for-T">Borrow&lt;T&gt;</a></li><li><a href="#impl-BorrowMut%3CT%3E-for-T">BorrowMut&lt;T&gt;</a></li><li><a href="#impl-Equivalent%3CK%3E-for-Q">Equivalent&lt;K&gt;</a></li><li><a href="#impl-From%3CT%3E-for-T">From&lt;T&gt;</a></li><li><a href="#impl-Into%3CU%3E-for-T">Into&lt;U&gt;</a></li><li><a href="#impl-ToOwned-for-T">ToOwned</a></li><li><a href="#impl-TryFrom%3CU%3E-for-T">TryFrom&lt;U&gt;</a></li><li><a href="#impl-TryInto%3CU%3E-for-T">TryInto&lt;U&gt;</a></li></ul></section><h2><a href="index.html">In hashbrown::hash_map</a></h2></div></nav><div class="sidebar-resizer"></div><main><div class="width-limiter"><rustdoc-search></rustdoc-search><section id="main-content" class="content"><div class="main-heading"><h1>Struct <a href="../index.html">hashbrown</a>::<wbr><a href="index.html">hash_map</a>::<wbr><a class="struct" href="#">HashMap</a><button id="copy-path" title="Copy item path to clipboard">Copy item path</button></h1><span class="out-of-band"><a class="src" href="../../src/hashbrown/map.rs.html#190-193">source</a> · <button id="toggle-all-docs" title="collapse all docs">[<span>&#x2212;</span>]</button></span></div><pre class="rust item-decl"><code>pub struct HashMap&lt;K, V, S = <a class="enum" href="enum.DefaultHashBuilder.html" title="enum hashbrown::hash_map::DefaultHashBuilder">DefaultHashBuilder</a>, A: Allocator = Global&gt; { <span class="comment">/* private fields */</span> }</code></pre><details class="toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>A hash map implemented with quadratic probing and SIMD lookup.</p>
<p>The default hashing algorithm is currently <a href="https://crates.io/crates/ahash"><code>AHash</code></a>, though this is
subject to change at any point in the future. This hash function is very
fast for all types of keys, but this algorithm will typically <em>not</em> protect
against attacks such as HashDoS.</p>
<p>The hashing algorithm can be replaced on a per-<code>HashMap</code> basis using the
<a href="#method.default"><code>default</code></a>, <a href="#method.with_hasher"><code>with_hasher</code></a>, and <a href="#method.with_capacity_and_hasher"><code>with_capacity_and_hasher</code></a> methods. Many
alternative algorithms are available on crates.io, such as the <a href="https://crates.io/crates/fnv"><code>fnv</code></a> crate.</p>
<p>It is required that the keys implement the <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> and <a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> traits, although
this can frequently be achieved by using <code>#[derive(PartialEq, Eq, Hash)]</code>.
If you implement these yourself, it is important that the following
property holds:</p>
<div class="example-wrap"><pre class="language-text"><code>k1 == k2 -&gt; hash(k1) == hash(k2)
</code></pre></div>
<p>In other words, if two keys are equal, their hashes must be equal.</p>
<p>It is a logic error for a key to be modified in such a way that the key’s
hash, as determined by the <a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> trait, or its equality, as determined by
the <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> trait, changes while it is in the map. This is normally only
possible through <a href="https://doc.rust-lang.org/std/cell/struct.Cell.html"><code>Cell</code></a>, <a href="https://doc.rust-lang.org/std/cell/struct.RefCell.html"><code>RefCell</code></a>, global state, I/O, or unsafe code.</p>
<p>It is also a logic error for the <a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> implementation of a key to panic.
This is generally only possible if the trait is implemented manually. If a
panic does occur then the contents of the <code>HashMap</code> may become corrupted and
some items may be dropped from the table.</p>
<h2 id="examples"><a class="doc-anchor" href="#examples">§</a>Examples</h2>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="comment">// Type inference lets us omit an explicit type signature (which
// would be `HashMap&lt;String, String&gt;` in this example).
</span><span class="kw">let </span><span class="kw-2">mut </span>book_reviews = HashMap::new();
<span class="comment">// Review some books.
</span>book_reviews.insert(
<span class="string">"Adventures of Huckleberry Finn"</span>.to_string(),
<span class="string">"My favorite book."</span>.to_string(),
);
book_reviews.insert(
<span class="string">"Grimms' Fairy Tales"</span>.to_string(),
<span class="string">"Masterpiece."</span>.to_string(),
);
book_reviews.insert(
<span class="string">"Pride and Prejudice"</span>.to_string(),
<span class="string">"Very enjoyable."</span>.to_string(),
);
book_reviews.insert(
<span class="string">"The Adventures of Sherlock Holmes"</span>.to_string(),
<span class="string">"Eye lyked it alot."</span>.to_string(),
);
<span class="comment">// Check for a specific one.
// When collections store owned values (String), they can still be
// queried using references (&amp;str).
</span><span class="kw">if </span>!book_reviews.contains_key(<span class="string">"Les Misérables"</span>) {
<span class="macro">println!</span>(<span class="string">"We've got {} reviews, but Les Misérables ain't one."</span>,
book_reviews.len());
}
<span class="comment">// oops, this review has a lot of spelling mistakes, let's delete it.
</span>book_reviews.remove(<span class="string">"The Adventures of Sherlock Holmes"</span>);
<span class="comment">// Look up the values associated with some keys.
</span><span class="kw">let </span>to_find = [<span class="string">"Pride and Prejudice"</span>, <span class="string">"Alice's Adventure in Wonderland"</span>];
<span class="kw">for </span><span class="kw-2">&amp;</span>book <span class="kw">in </span><span class="kw-2">&amp;</span>to_find {
<span class="kw">match </span>book_reviews.get(book) {
<span class="prelude-val">Some</span>(review) =&gt; <span class="macro">println!</span>(<span class="string">"{}: {}"</span>, book, review),
<span class="prelude-val">None </span>=&gt; <span class="macro">println!</span>(<span class="string">"{} is unreviewed."</span>, book)
}
}
<span class="comment">// Look up the value for a key (will panic if the key is not found).
</span><span class="macro">println!</span>(<span class="string">"Review for Jane: {}"</span>, book_reviews[<span class="string">"Pride and Prejudice"</span>]);
<span class="comment">// Iterate over everything.
</span><span class="kw">for </span>(book, review) <span class="kw">in </span><span class="kw-2">&amp;</span>book_reviews {
<span class="macro">println!</span>(<span class="string">"{}: \"{}\""</span>, book, review);
}</code></pre></div>
<p><code>HashMap</code> also implements an <a href="#method.entry"><code>Entry API</code></a>, which allows
for more complex methods of getting, setting, updating and removing keys and
their values:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="comment">// type inference lets us omit an explicit type signature (which
// would be `HashMap&lt;&amp;str, u8&gt;` in this example).
</span><span class="kw">let </span><span class="kw-2">mut </span>player_stats = HashMap::new();
<span class="kw">fn </span>random_stat_buff() -&gt; u8 {
<span class="comment">// could actually return some random value here - let's just return
// some fixed value for now
</span><span class="number">42
</span>}
<span class="comment">// insert a key only if it doesn't already exist
</span>player_stats.entry(<span class="string">"health"</span>).or_insert(<span class="number">100</span>);
<span class="comment">// insert a key using a function that provides a new value only if it
// doesn't already exist
</span>player_stats.entry(<span class="string">"defence"</span>).or_insert_with(random_stat_buff);
<span class="comment">// update a key, guarding against the key possibly not being set
</span><span class="kw">let </span>stat = player_stats.entry(<span class="string">"attack"</span>).or_insert(<span class="number">100</span>);
<span class="kw-2">*</span>stat += random_stat_buff();</code></pre></div>
<p>The easiest way to use <code>HashMap</code> with a custom key type is to derive <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> and <a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a>.
We must also derive <a href="https://doc.rust-lang.org/std/cmp/trait.PartialEq.html"><code>PartialEq</code></a>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="attr">#[derive(Hash, Eq, PartialEq, Debug)]
</span><span class="kw">struct </span>Viking {
name: String,
country: String,
}
<span class="kw">impl </span>Viking {
<span class="doccomment">/// Creates a new Viking.
</span><span class="kw">fn </span>new(name: <span class="kw-2">&amp;</span>str, country: <span class="kw-2">&amp;</span>str) -&gt; Viking {
Viking { name: name.to_string(), country: country.to_string() }
}
}
<span class="comment">// Use a HashMap to store the vikings' health points.
</span><span class="kw">let </span><span class="kw-2">mut </span>vikings = HashMap::new();
vikings.insert(Viking::new(<span class="string">"Einar"</span>, <span class="string">"Norway"</span>), <span class="number">25</span>);
vikings.insert(Viking::new(<span class="string">"Olaf"</span>, <span class="string">"Denmark"</span>), <span class="number">24</span>);
vikings.insert(Viking::new(<span class="string">"Harald"</span>, <span class="string">"Iceland"</span>), <span class="number">12</span>);
<span class="comment">// Use derived implementation to print the status of the vikings.
</span><span class="kw">for </span>(viking, health) <span class="kw">in </span><span class="kw-2">&amp;</span>vikings {
<span class="macro">println!</span>(<span class="string">"{:?} has {} hp"</span>, viking, health);
}</code></pre></div>
<p>A <code>HashMap</code> with fixed list of elements can be initialized from an array:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span>timber_resources: HashMap&lt;<span class="kw-2">&amp;</span>str, i32&gt; = [(<span class="string">"Norway"</span>, <span class="number">100</span>), (<span class="string">"Denmark"</span>, <span class="number">50</span>), (<span class="string">"Iceland"</span>, <span class="number">10</span>)]
.into_iter().collect();
<span class="comment">// use the values stored in map</span></code></pre></div>
</div></details><h2 id="implementations" class="section-header">Implementations<a href="#implementations" class="anchor">§</a></h2><div id="implementations-list"><details class="toggle implementors-toggle" open><summary><section id="impl-HashMap%3CK,+V,+S%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#424-508">source</a><a href="#impl-HashMap%3CK,+V,+S%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S&gt; <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.with_hasher" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#460-465">source</a><h4 class="code-header">pub const fn <a href="#method.with_hasher" class="fn">with_hasher</a>(hash_builder: S) -&gt; Self</h4></section></summary><div class="docblock"><p>Creates an empty <code>HashMap</code> which will use the given hash builder to hash
keys.</p>
<p>The hash map is initially created with a capacity of 0, so it will not
allocate until it is first inserted into.</p>
<h5 id="hashdos-resistance"><a class="doc-anchor" href="#hashdos-resistance">§</a>HashDoS resistance</h5>
<p>The <code>hash_builder</code> normally use a fixed key by default and that does
not allow the <code>HashMap</code> to be protected against attacks such as <a href="https://en.wikipedia.org/wiki/Collision_attack"><code>HashDoS</code></a>.
Users who require HashDoS resistance should explicitly use
[<code>ahash::RandomState</code>] or <a href="https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html"><code>std::collections::hash_map::RandomState</code></a>
as the hasher when creating a <a href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap"><code>HashMap</code></a>.</p>
<p>The <code>hash_builder</code> passed should implement the <a href="https://doc.rust-lang.org/std/hash/trait.BuildHasher.html"><code>BuildHasher</code></a> trait for
the HashMap to be useful, see its documentation for details.</p>
<h5 id="examples-1"><a class="doc-anchor" href="#examples-1">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">use </span>hashbrown::hash_map::DefaultHashBuilder;
<span class="kw">let </span>s = DefaultHashBuilder::default();
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::with_hasher(s);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">0</span>);
<span class="macro">assert_eq!</span>(map.capacity(), <span class="number">0</span>);
map.insert(<span class="number">1</span>, <span class="number">2</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.with_capacity_and_hasher" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#502-507">source</a><h4 class="code-header">pub fn <a href="#method.with_capacity_and_hasher" class="fn">with_capacity_and_hasher</a>(capacity: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>, hash_builder: S) -&gt; Self</h4></section></summary><div class="docblock"><p>Creates an empty <code>HashMap</code> with the specified capacity, using <code>hash_builder</code>
to hash the keys.</p>
<p>The hash map will be able to hold at least <code>capacity</code> elements without
reallocating. If <code>capacity</code> is 0, the hash map will not allocate.</p>
<h5 id="hashdos-resistance-1"><a class="doc-anchor" href="#hashdos-resistance-1">§</a>HashDoS resistance</h5>
<p>The <code>hash_builder</code> normally use a fixed key by default and that does
not allow the <code>HashMap</code> to be protected against attacks such as <a href="https://en.wikipedia.org/wiki/Collision_attack"><code>HashDoS</code></a>.
Users who require HashDoS resistance should explicitly use
[<code>ahash::RandomState</code>] or <a href="https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html"><code>std::collections::hash_map::RandomState</code></a>
as the hasher when creating a <a href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap"><code>HashMap</code></a>.</p>
<p>The <code>hash_builder</code> passed should implement the <a href="https://doc.rust-lang.org/std/hash/trait.BuildHasher.html"><code>BuildHasher</code></a> trait for
the HashMap to be useful, see its documentation for details.</p>
<h5 id="examples-2"><a class="doc-anchor" href="#examples-2">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">use </span>hashbrown::hash_map::DefaultHashBuilder;
<span class="kw">let </span>s = DefaultHashBuilder::default();
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::with_capacity_and_hasher(<span class="number">10</span>, s);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">0</span>);
<span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">10</span>);
map.insert(<span class="number">1</span>, <span class="number">2</span>);</code></pre></div>
</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#510-1070">source</a><a href="#impl-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A: Allocator&gt; <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.allocator" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#513-515">source</a><h4 class="code-header">pub fn <a href="#method.allocator" class="fn">allocator</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;A</a></h4></section></summary><div class="docblock"><p>Returns a reference to the underlying allocator.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.with_hasher_in" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#545-550">source</a><h4 class="code-header">pub const fn <a href="#method.with_hasher_in" class="fn">with_hasher_in</a>(hash_builder: S, alloc: A) -&gt; Self</h4></section></summary><div class="docblock"><p>Creates an empty <code>HashMap</code> which will use the given hash builder to hash
keys. It will be allocated with the given allocator.</p>
<p>The hash map is initially created with a capacity of 0, so it will not allocate until it
is first inserted into.</p>
<h5 id="hashdos-resistance-2"><a class="doc-anchor" href="#hashdos-resistance-2">§</a>HashDoS resistance</h5>
<p>The <code>hash_builder</code> normally use a fixed key by default and that does
not allow the <code>HashMap</code> to be protected against attacks such as <a href="https://en.wikipedia.org/wiki/Collision_attack"><code>HashDoS</code></a>.
Users who require HashDoS resistance should explicitly use
[<code>ahash::RandomState</code>] or <a href="https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html"><code>std::collections::hash_map::RandomState</code></a>
as the hasher when creating a <a href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap"><code>HashMap</code></a>.</p>
<h5 id="examples-3"><a class="doc-anchor" href="#examples-3">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">use </span>hashbrown::hash_map::DefaultHashBuilder;
<span class="kw">let </span>s = DefaultHashBuilder::default();
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::with_hasher(s);
map.insert(<span class="number">1</span>, <span class="number">2</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.with_capacity_and_hasher_in" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#580-585">source</a><h4 class="code-header">pub fn <a href="#method.with_capacity_and_hasher_in" class="fn">with_capacity_and_hasher_in</a>(
capacity: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>,
hash_builder: S,
alloc: A,
) -&gt; Self</h4></section></summary><div class="docblock"><p>Creates an empty <code>HashMap</code> with the specified capacity, using <code>hash_builder</code>
to hash the keys. It will be allocated with the given allocator.</p>
<p>The hash map will be able to hold at least <code>capacity</code> elements without
reallocating. If <code>capacity</code> is 0, the hash map will not allocate.</p>
<h5 id="hashdos-resistance-3"><a class="doc-anchor" href="#hashdos-resistance-3">§</a>HashDoS resistance</h5>
<p>The <code>hash_builder</code> normally use a fixed key by default and that does
not allow the <code>HashMap</code> to be protected against attacks such as <a href="https://en.wikipedia.org/wiki/Collision_attack"><code>HashDoS</code></a>.
Users who require HashDoS resistance should explicitly use
[<code>ahash::RandomState</code>] or <a href="https://doc.rust-lang.org/std/collections/hash_map/struct.RandomState.html"><code>std::collections::hash_map::RandomState</code></a>
as the hasher when creating a <a href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap"><code>HashMap</code></a>.</p>
<h5 id="examples-4"><a class="doc-anchor" href="#examples-4">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">use </span>hashbrown::hash_map::DefaultHashBuilder;
<span class="kw">let </span>s = DefaultHashBuilder::default();
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::with_capacity_and_hasher(<span class="number">10</span>, s);
map.insert(<span class="number">1</span>, <span class="number">2</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.hasher" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#602-604">source</a><h4 class="code-header">pub fn <a href="#method.hasher" class="fn">hasher</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;S</a></h4></section></summary><div class="docblock"><p>Returns a reference to the map’s <a href="https://doc.rust-lang.org/std/hash/trait.BuildHasher.html"><code>BuildHasher</code></a>.</p>
<h5 id="examples-5"><a class="doc-anchor" href="#examples-5">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">use </span>hashbrown::hash_map::DefaultHashBuilder;
<span class="kw">let </span>hasher = DefaultHashBuilder::default();
<span class="kw">let </span>map: HashMap&lt;i32, i32&gt; = HashMap::with_hasher(hasher);
<span class="kw">let </span>hasher: <span class="kw-2">&amp;</span>DefaultHashBuilder = map.hasher();</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.capacity" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#620-622">source</a><h4 class="code-header">pub fn <a href="#method.capacity" class="fn">capacity</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a></h4></section></summary><div class="docblock"><p>Returns the number of elements the map can hold without reallocating.</p>
<p>This number is a lower bound; the <code>HashMap&lt;K, V&gt;</code> might be able to hold
more, but is guaranteed to be able to hold at least this many.</p>
<h5 id="examples-6"><a class="doc-anchor" href="#examples-6">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span>map: HashMap&lt;i32, i32&gt; = HashMap::with_capacity(<span class="number">100</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">0</span>);
<span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">100</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.keys" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#652-654">source</a><h4 class="code-header">pub fn <a href="#method.keys" class="fn">keys</a>(&amp;self) -&gt; <a class="struct" href="struct.Keys.html" title="struct hashbrown::hash_map::Keys">Keys</a>&lt;'_, K, V&gt; <a href="#" class="tooltip" data-notable-ty="Keys&lt;&#39;_, K, V&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>An iterator visiting all keys in arbitrary order.
The iterator element type is <code>&amp;'a K</code>.</p>
<h5 id="examples-7"><a class="doc-anchor" href="#examples-7">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="string">"a"</span>, <span class="number">1</span>);
map.insert(<span class="string">"b"</span>, <span class="number">2</span>);
map.insert(<span class="string">"c"</span>, <span class="number">3</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;<span class="kw-2">&amp;</span>str&gt; = Vec::new();
<span class="kw">for </span>key <span class="kw">in </span>map.keys() {
<span class="macro">println!</span>(<span class="string">"{}"</span>, key);
vec.push(<span class="kw-2">*</span>key);
}
<span class="comment">// The `Keys` iterator produces keys in arbitrary order, so the
// keys must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [<span class="string">"a"</span>, <span class="string">"b"</span>, <span class="string">"c"</span>]);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.values" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#684-686">source</a><h4 class="code-header">pub fn <a href="#method.values" class="fn">values</a>(&amp;self) -&gt; <a class="struct" href="struct.Values.html" title="struct hashbrown::hash_map::Values">Values</a>&lt;'_, K, V&gt; <a href="#" class="tooltip" data-notable-ty="Values&lt;&#39;_, K, V&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>An iterator visiting all values in arbitrary order.
The iterator element type is <code>&amp;'a V</code>.</p>
<h5 id="examples-8"><a class="doc-anchor" href="#examples-8">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="string">"a"</span>, <span class="number">1</span>);
map.insert(<span class="string">"b"</span>, <span class="number">2</span>);
map.insert(<span class="string">"c"</span>, <span class="number">3</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;i32&gt; = Vec::new();
<span class="kw">for </span>val <span class="kw">in </span>map.values() {
<span class="macro">println!</span>(<span class="string">"{}"</span>, val);
vec.push(<span class="kw-2">*</span>val);
}
<span class="comment">// The `Values` iterator produces values in arbitrary order, so the
// values must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.values_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#722-726">source</a><h4 class="code-header">pub fn <a href="#method.values_mut" class="fn">values_mut</a>(&amp;mut self) -&gt; <a class="struct" href="struct.ValuesMut.html" title="struct hashbrown::hash_map::ValuesMut">ValuesMut</a>&lt;'_, K, V&gt; <a href="#" class="tooltip" data-notable-ty="ValuesMut&lt;&#39;_, K, V&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>An iterator visiting all values mutably in arbitrary order.
The iterator element type is <code>&amp;'a mut V</code>.</p>
<h5 id="examples-9"><a class="doc-anchor" href="#examples-9">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="string">"a"</span>, <span class="number">1</span>);
map.insert(<span class="string">"b"</span>, <span class="number">2</span>);
map.insert(<span class="string">"c"</span>, <span class="number">3</span>);
<span class="kw">for </span>val <span class="kw">in </span>map.values_mut() {
<span class="kw-2">*</span>val = <span class="kw-2">*</span>val + <span class="number">10</span>;
}
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;i32&gt; = Vec::new();
<span class="kw">for </span>val <span class="kw">in </span>map.values() {
<span class="macro">println!</span>(<span class="string">"{}"</span>, val);
vec.push(<span class="kw-2">*</span>val);
}
<span class="comment">// The `Values` iterator produces values in arbitrary order, so the
// values must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [<span class="number">11</span>, <span class="number">12</span>, <span class="number">13</span>]);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.iter" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#756-764">source</a><h4 class="code-header">pub fn <a href="#method.iter" class="fn">iter</a>(&amp;self) -&gt; <a class="struct" href="struct.Iter.html" title="struct hashbrown::hash_map::Iter">Iter</a>&lt;'_, K, V&gt; <a href="#" class="tooltip" data-notable-ty="Iter&lt;&#39;_, K, V&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>An iterator visiting all key-value pairs in arbitrary order.
The iterator element type is <code>(&amp;'a K, &amp;'a V)</code>.</p>
<h5 id="examples-10"><a class="doc-anchor" href="#examples-10">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="string">"a"</span>, <span class="number">1</span>);
map.insert(<span class="string">"b"</span>, <span class="number">2</span>);
map.insert(<span class="string">"c"</span>, <span class="number">3</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;(<span class="kw-2">&amp;</span>str, i32)&gt; = Vec::new();
<span class="kw">for </span>(key, val) <span class="kw">in </span>map.iter() {
<span class="macro">println!</span>(<span class="string">"key: {} val: {}"</span>, key, val);
vec.push((<span class="kw-2">*</span>key, <span class="kw-2">*</span>val));
}
<span class="comment">// The `Iter` iterator produces items in arbitrary order, so the
// items must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [(<span class="string">"a"</span>, <span class="number">1</span>), (<span class="string">"b"</span>, <span class="number">2</span>), (<span class="string">"c"</span>, <span class="number">3</span>)]);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.iter_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#801-809">source</a><h4 class="code-header">pub fn <a href="#method.iter_mut" class="fn">iter_mut</a>(&amp;mut self) -&gt; <a class="struct" href="struct.IterMut.html" title="struct hashbrown::hash_map::IterMut">IterMut</a>&lt;'_, K, V&gt; <a href="#" class="tooltip" data-notable-ty="IterMut&lt;&#39;_, K, V&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>An iterator visiting all key-value pairs in arbitrary order,
with mutable references to the values.
The iterator element type is <code>(&amp;'a K, &amp;'a mut V)</code>.</p>
<h5 id="examples-11"><a class="doc-anchor" href="#examples-11">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="string">"a"</span>, <span class="number">1</span>);
map.insert(<span class="string">"b"</span>, <span class="number">2</span>);
map.insert(<span class="string">"c"</span>, <span class="number">3</span>);
<span class="comment">// Update all values
</span><span class="kw">for </span>(<span class="kw">_</span>, val) <span class="kw">in </span>map.iter_mut() {
<span class="kw-2">*</span>val <span class="kw-2">*</span>= <span class="number">2</span>;
}
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;(<span class="kw-2">&amp;</span>str, i32)&gt; = Vec::new();
<span class="kw">for </span>(key, val) <span class="kw">in </span><span class="kw-2">&amp;</span>map {
<span class="macro">println!</span>(<span class="string">"key: {} val: {}"</span>, key, val);
vec.push((<span class="kw-2">*</span>key, <span class="kw-2">*</span>val));
}
<span class="comment">// The `Iter` iterator produces items in arbitrary order, so the
// items must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [(<span class="string">"a"</span>, <span class="number">2</span>), (<span class="string">"b"</span>, <span class="number">4</span>), (<span class="string">"c"</span>, <span class="number">6</span>)]);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.len" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#830-832">source</a><h4 class="code-header">pub fn <a href="#method.len" class="fn">len</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a></h4></section></summary><div class="docblock"><p>Returns the number of elements in the map.</p>
<h5 id="examples-12"><a class="doc-anchor" href="#examples-12">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>a = HashMap::new();
<span class="macro">assert_eq!</span>(a.len(), <span class="number">0</span>);
a.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(a.len(), <span class="number">1</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.is_empty" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#847-849">source</a><h4 class="code-header">pub fn <a href="#method.is_empty" class="fn">is_empty</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns <code>true</code> if the map contains no elements.</p>
<h5 id="examples-13"><a class="doc-anchor" href="#examples-13">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>a = HashMap::new();
<span class="macro">assert!</span>(a.is_empty());
a.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="macro">assert!</span>(!a.is_empty());</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.drain" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#890-894">source</a><h4 class="code-header">pub fn <a href="#method.drain" class="fn">drain</a>(&amp;mut self) -&gt; <a class="struct" href="struct.Drain.html" title="struct hashbrown::hash_map::Drain">Drain</a>&lt;'_, K, V, A&gt; <a href="#" class="tooltip" data-notable-ty="Drain&lt;&#39;_, K, V, A&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>Clears the map, returning all key-value pairs as an iterator. Keeps the
allocated memory for reuse.</p>
<p>If the returned iterator is dropped before being fully consumed, it
drops the remaining key-value pairs. The returned iterator keeps a
mutable borrow on the vector to optimize its implementation.</p>
<h5 id="examples-14"><a class="doc-anchor" href="#examples-14">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>a = HashMap::new();
a.insert(<span class="number">1</span>, <span class="string">"a"</span>);
a.insert(<span class="number">2</span>, <span class="string">"b"</span>);
<span class="kw">let </span>capacity_before_drain = a.capacity();
<span class="kw">for </span>(k, v) <span class="kw">in </span>a.drain().take(<span class="number">1</span>) {
<span class="macro">assert!</span>(k == <span class="number">1 </span>|| k == <span class="number">2</span>);
<span class="macro">assert!</span>(v == <span class="string">"a" </span>|| v == <span class="string">"b"</span>);
}
<span class="comment">// As we can see, the map is empty and contains no element.
</span><span class="macro">assert!</span>(a.is_empty() &amp;&amp; a.len() == <span class="number">0</span>);
<span class="comment">// But map capacity is equal to old one.
</span><span class="macro">assert_eq!</span>(a.capacity(), capacity_before_drain);
<span class="kw">let </span><span class="kw-2">mut </span>a = HashMap::new();
a.insert(<span class="number">1</span>, <span class="string">"a"</span>);
a.insert(<span class="number">2</span>, <span class="string">"b"</span>);
{ <span class="comment">// Iterator is dropped without being consumed.
</span><span class="kw">let </span>d = a.drain();
}
<span class="comment">// But the map is empty even if we do not use Drain iterator.
</span><span class="macro">assert!</span>(a.is_empty());</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.retain" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#919-932">source</a><h4 class="code-header">pub fn <a href="#method.retain" class="fn">retain</a>&lt;F&gt;(&amp;mut self, f: F)<div class="where">where
F: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.bool.html">bool</a>,</div></h4></section></summary><div class="docblock"><p>Retains only the elements specified by the predicate. Keeps the
allocated memory for reuse.</p>
<p>In other words, remove all pairs <code>(k, v)</code> such that <code>f(&amp;k, &amp;mut v)</code> returns <code>false</code>.
The elements are visited in unsorted (and unspecified) order.</p>
<h5 id="examples-15"><a class="doc-anchor" href="#examples-15">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;i32, i32&gt; = (<span class="number">0</span>..<span class="number">8</span>).map(|x|(x, x<span class="kw-2">*</span><span class="number">10</span>)).collect();
<span class="macro">assert_eq!</span>(map.len(), <span class="number">8</span>);
map.retain(|<span class="kw-2">&amp;</span>k, <span class="kw">_</span>| k % <span class="number">2 </span>== <span class="number">0</span>);
<span class="comment">// We can see, that the number of elements inside map is changed.
</span><span class="macro">assert_eq!</span>(map.len(), <span class="number">4</span>);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;(i32, i32)&gt; = map.iter().map(|(<span class="kw-2">&amp;</span>k, <span class="kw-2">&amp;</span>v)| (k, v)).collect();
vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [(<span class="number">0</span>, <span class="number">0</span>), (<span class="number">2</span>, <span class="number">20</span>), (<span class="number">4</span>, <span class="number">40</span>), (<span class="number">6</span>, <span class="number">60</span>)]);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.extract_if" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#978-989">source</a><h4 class="code-header">pub fn <a href="#method.extract_if" class="fn">extract_if</a>&lt;F&gt;(&amp;mut self, f: F) -&gt; <a class="struct" href="struct.ExtractIf.html" title="struct hashbrown::hash_map::ExtractIf">ExtractIf</a>&lt;'_, K, V, F, A&gt; <a href="#" class="tooltip" data-notable-ty="ExtractIf&lt;&#39;_, K, V, F, A&gt;">ⓘ</a><div class="where">where
F: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/ops/function/trait.FnMut.html" title="trait core::ops::function::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.bool.html">bool</a>,</div></h4></section></summary><div class="docblock"><p>Drains elements which are true under the given predicate,
and returns an iterator over the removed items.</p>
<p>In other words, move all pairs <code>(k, v)</code> such that <code>f(&amp;k, &amp;mut v)</code> returns <code>true</code> out
into another iterator.</p>
<p>Note that <code>extract_if</code> lets you mutate every value in the filter closure, regardless of
whether you choose to keep or remove it.</p>
<p>If the returned <code>ExtractIf</code> is not exhausted, e.g. because it is dropped without iterating
or the iteration short-circuits, then the remaining elements will be retained.
Use <a href="struct.HashMap.html#method.retain" title="method hashbrown::hash_map::HashMap::retain"><code>retain()</code></a> with a negated predicate if you do not need the returned iterator.</p>
<p>Keeps the allocated memory for reuse.</p>
<h5 id="examples-16"><a class="doc-anchor" href="#examples-16">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;i32, i32&gt; = (<span class="number">0</span>..<span class="number">8</span>).map(|x| (x, x)).collect();
<span class="kw">let </span>drained: HashMap&lt;i32, i32&gt; = map.extract_if(|k, _v| k % <span class="number">2 </span>== <span class="number">0</span>).collect();
<span class="kw">let </span><span class="kw-2">mut </span>evens = drained.keys().cloned().collect::&lt;Vec&lt;<span class="kw">_</span>&gt;&gt;();
<span class="kw">let </span><span class="kw-2">mut </span>odds = map.keys().cloned().collect::&lt;Vec&lt;<span class="kw">_</span>&gt;&gt;();
evens.sort();
odds.sort();
<span class="macro">assert_eq!</span>(evens, <span class="macro">vec!</span>[<span class="number">0</span>, <span class="number">2</span>, <span class="number">4</span>, <span class="number">6</span>]);
<span class="macro">assert_eq!</span>(odds, <span class="macro">vec!</span>[<span class="number">1</span>, <span class="number">3</span>, <span class="number">5</span>, <span class="number">7</span>]);
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;i32, i32&gt; = (<span class="number">0</span>..<span class="number">8</span>).map(|x| (x, x)).collect();
{ <span class="comment">// Iterator is dropped without being consumed.
</span><span class="kw">let </span>d = map.extract_if(|k, _v| k % <span class="number">2 </span>!= <span class="number">0</span>);
}
<span class="comment">// ExtractIf was not exhausted, therefore no elements were drained.
</span><span class="macro">assert_eq!</span>(map.len(), <span class="number">8</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.clear" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1011-1013">source</a><h4 class="code-header">pub fn <a href="#method.clear" class="fn">clear</a>(&amp;mut self)</h4></section></summary><div class="docblock"><p>Clears the map, removing all key-value pairs. Keeps the allocated memory
for reuse.</p>
<h5 id="examples-17"><a class="doc-anchor" href="#examples-17">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>a = HashMap::new();
a.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="kw">let </span>capacity_before_clear = a.capacity();
a.clear();
<span class="comment">// Map is empty.
</span><span class="macro">assert!</span>(a.is_empty());
<span class="comment">// But map capacity is equal to old one.
</span><span class="macro">assert_eq!</span>(a.capacity(), capacity_before_clear);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.into_keys" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1037-1041">source</a><h4 class="code-header">pub fn <a href="#method.into_keys" class="fn">into_keys</a>(self) -&gt; <a class="struct" href="struct.IntoKeys.html" title="struct hashbrown::hash_map::IntoKeys">IntoKeys</a>&lt;K, V, A&gt; <a href="#" class="tooltip" data-notable-ty="IntoKeys&lt;K, V, A&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>Creates a consuming iterator visiting all the keys in arbitrary order.
The map cannot be used after calling this.
The iterator element type is <code>K</code>.</p>
<h5 id="examples-18"><a class="doc-anchor" href="#examples-18">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="string">"a"</span>, <span class="number">1</span>);
map.insert(<span class="string">"b"</span>, <span class="number">2</span>);
map.insert(<span class="string">"c"</span>, <span class="number">3</span>);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;<span class="kw-2">&amp;</span>str&gt; = map.into_keys().collect();
<span class="comment">// The `IntoKeys` iterator produces keys in arbitrary order, so the
// keys must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [<span class="string">"a"</span>, <span class="string">"b"</span>, <span class="string">"c"</span>]);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.into_values" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1065-1069">source</a><h4 class="code-header">pub fn <a href="#method.into_values" class="fn">into_values</a>(self) -&gt; <a class="struct" href="struct.IntoValues.html" title="struct hashbrown::hash_map::IntoValues">IntoValues</a>&lt;K, V, A&gt; <a href="#" class="tooltip" data-notable-ty="IntoValues&lt;K, V, A&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>Creates a consuming iterator visiting all the values in arbitrary order.
The map cannot be used after calling this.
The iterator element type is <code>V</code>.</p>
<h5 id="examples-19"><a class="doc-anchor" href="#examples-19">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="string">"a"</span>, <span class="number">1</span>);
map.insert(<span class="string">"b"</span>, <span class="number">2</span>);
map.insert(<span class="string">"c"</span>, <span class="number">3</span>);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;i32&gt; = map.into_values().collect();
<span class="comment">// The `IntoValues` iterator produces values in arbitrary order, so
// the values must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]);</code></pre></div>
</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-HashMap%3CK,+V,+S,+A%3E-1" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1072-1941">source</a><a href="#impl-HashMap%3CK,+V,+S,+A%3E-1" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>,
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.BuildHasher.html" title="trait core::hash::BuildHasher">BuildHasher</a>,
A: Allocator,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.reserve" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1105-1108">source</a><h4 class="code-header">pub fn <a href="#method.reserve" class="fn">reserve</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>)</h4></section></summary><div class="docblock"><p>Reserves capacity for at least <code>additional</code> more elements to be inserted
in the <code>HashMap</code>. The collection may reserve more space to avoid
frequent reallocations.</p>
<h5 id="panics"><a class="doc-anchor" href="#panics">§</a>Panics</h5>
<p>Panics if the new capacity exceeds <a href="https://doc.rust-lang.org/std/primitive.isize.html"><code>isize::MAX</code></a> bytes and <a href="https://doc.rust-lang.org/alloc/alloc/fn.handle_alloc_error.html"><code>abort</code></a> the program
in case of allocation error. Use <a href="struct.HashMap.html#method.try_reserve" title="method hashbrown::hash_map::HashMap::try_reserve"><code>try_reserve</code></a> instead
if you want to handle memory allocation failure.</p>
<h5 id="examples-20"><a class="doc-anchor" href="#examples-20">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;<span class="kw-2">&amp;</span>str, i32&gt; = HashMap::new();
<span class="comment">// Map is empty and doesn't allocate memory
</span><span class="macro">assert_eq!</span>(map.capacity(), <span class="number">0</span>);
map.reserve(<span class="number">10</span>);
<span class="comment">// And now map can hold at least 10 elements
</span><span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">10</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.try_reserve" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1155-1158">source</a><h4 class="code-header">pub fn <a href="#method.try_reserve" class="fn">try_reserve</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.unit.html">()</a>, <a class="enum" href="../enum.TryReserveError.html" title="enum hashbrown::TryReserveError">TryReserveError</a>&gt;</h4></section></summary><div class="docblock"><p>Tries to reserve capacity for at least <code>additional</code> more elements to be inserted
in the given <code>HashMap&lt;K,V&gt;</code>. The collection may reserve more space to avoid
frequent reallocations.</p>
<h5 id="errors"><a class="doc-anchor" href="#errors">§</a>Errors</h5>
<p>If the capacity overflows, or the allocator reports a failure, then an error
is returned.</p>
<h5 id="examples-21"><a class="doc-anchor" href="#examples-21">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;<span class="kw-2">&amp;</span>str, isize&gt; = HashMap::new();
<span class="comment">// Map is empty and doesn't allocate memory
</span><span class="macro">assert_eq!</span>(map.capacity(), <span class="number">0</span>);
map.try_reserve(<span class="number">10</span>).expect(<span class="string">"why is the test harness OOMing on 10 bytes?"</span>);
<span class="comment">// And now map can hold at least 10 elements
</span><span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">10</span>);</code></pre></div>
<p>If the capacity overflows, or the allocator reports a failure, then an error
is returned:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">use </span>hashbrown::TryReserveError;
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;i32, i32&gt; = HashMap::new();
<span class="kw">match </span>map.try_reserve(usize::MAX) {
<span class="prelude-val">Err</span>(error) =&gt; <span class="kw">match </span>error {
TryReserveError::CapacityOverflow =&gt; {}
<span class="kw">_ </span>=&gt; <span class="macro">panic!</span>(<span class="string">"TryReserveError::AllocError ?"</span>),
},
<span class="kw">_ </span>=&gt; <span class="macro">panic!</span>(),
}</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.shrink_to_fit" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1177-1180">source</a><h4 class="code-header">pub fn <a href="#method.shrink_to_fit" class="fn">shrink_to_fit</a>(&amp;mut self)</h4></section></summary><div class="docblock"><p>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.</p>
<h5 id="examples-22"><a class="doc-anchor" href="#examples-22">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;i32, i32&gt; = HashMap::with_capacity(<span class="number">100</span>);
map.insert(<span class="number">1</span>, <span class="number">2</span>);
map.insert(<span class="number">3</span>, <span class="number">4</span>);
<span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">100</span>);
map.shrink_to_fit();
<span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">2</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.shrink_to" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1206-1209">source</a><h4 class="code-header">pub fn <a href="#method.shrink_to" class="fn">shrink_to</a>(&amp;mut self, min_capacity: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>)</h4></section></summary><div class="docblock"><p>Shrinks the capacity of the map with a lower limit. It will drop
down no lower than the supplied limit while maintaining the internal rules
and possibly leaving some space in accordance with the resize policy.</p>
<p>This function does nothing if the current capacity is smaller than the
supplied minimum capacity.</p>
<h5 id="examples-23"><a class="doc-anchor" href="#examples-23">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;i32, i32&gt; = HashMap::with_capacity(<span class="number">100</span>);
map.insert(<span class="number">1</span>, <span class="number">2</span>);
map.insert(<span class="number">3</span>, <span class="number">4</span>);
<span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">100</span>);
map.shrink_to(<span class="number">10</span>);
<span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">10</span>);
map.shrink_to(<span class="number">0</span>);
<span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">2</span>);
map.shrink_to(<span class="number">10</span>);
<span class="macro">assert!</span>(map.capacity() &gt;= <span class="number">2</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.entry" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1231-1247">source</a><h4 class="code-header">pub fn <a href="#method.entry" class="fn">entry</a>(&amp;mut self, key: K) -&gt; <a class="enum" href="enum.Entry.html" title="enum hashbrown::hash_map::Entry">Entry</a>&lt;'_, K, V, S, A&gt;</h4></section></summary><div class="docblock"><p>Gets the given key’s corresponding entry in the map for in-place manipulation.</p>
<h5 id="examples-24"><a class="doc-anchor" href="#examples-24">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>letters = HashMap::new();
<span class="kw">for </span>ch <span class="kw">in </span><span class="string">"a short treatise on fungi"</span>.chars() {
<span class="kw">let </span>counter = letters.entry(ch).or_insert(<span class="number">0</span>);
<span class="kw-2">*</span>counter += <span class="number">1</span>;
}
<span class="macro">assert_eq!</span>(letters[<span class="kw-2">&amp;</span><span class="string">'s'</span>], <span class="number">2</span>);
<span class="macro">assert_eq!</span>(letters[<span class="kw-2">&amp;</span><span class="string">'t'</span>], <span class="number">3</span>);
<span class="macro">assert_eq!</span>(letters[<span class="kw-2">&amp;</span><span class="string">'u'</span>], <span class="number">1</span>);
<span class="macro">assert_eq!</span>(letters.get(<span class="kw-2">&amp;</span><span class="string">'y'</span>), <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.entry_ref" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1267-1286">source</a><h4 class="code-header">pub fn <a href="#method.entry_ref" class="fn">entry_ref</a>&lt;'a, 'b, Q&gt;(
&amp;'a mut self,
key: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'b Q</a>,
) -&gt; <a class="enum" href="enum.EntryRef.html" title="enum hashbrown::hash_map::EntryRef">EntryRef</a>&lt;'a, 'b, K, Q, V, S, A&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Gets the given key’s corresponding entry by reference in the map for in-place manipulation.</p>
<h5 id="examples-25"><a class="doc-anchor" href="#examples-25">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>words: HashMap&lt;String, usize&gt; = HashMap::new();
<span class="kw">let </span>source = [<span class="string">"poneyland"</span>, <span class="string">"horseyland"</span>, <span class="string">"poneyland"</span>, <span class="string">"poneyland"</span>];
<span class="kw">for </span>(i, <span class="kw-2">&amp;</span>s) <span class="kw">in </span>source.iter().enumerate() {
<span class="kw">let </span>counter = words.entry_ref(s).or_insert(<span class="number">0</span>);
<span class="kw-2">*</span>counter += <span class="number">1</span>;
}
<span class="macro">assert_eq!</span>(words[<span class="string">"poneyland"</span>], <span class="number">3</span>);
<span class="macro">assert_eq!</span>(words[<span class="string">"horseyland"</span>], <span class="number">1</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.get" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1308-1317">source</a><h4 class="code-header">pub fn <a href="#method.get" class="fn">get</a>&lt;Q&gt;(&amp;self, k: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;V</a>&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Returns a reference to the value corresponding to the key.</p>
<p>The key may be any borrowed form of the map’s key type, but
<a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> and <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> on the borrowed form <em>must</em> match those for
the key type.</p>
<h5 id="examples-26"><a class="doc-anchor" href="#examples-26">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(map.get(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="string">"a"</span>));
<span class="macro">assert_eq!</span>(map.get(<span class="kw-2">&amp;</span><span class="number">2</span>), <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_key_value" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1339-1348">source</a><h4 class="code-header">pub fn <a href="#method.get_key_value" class="fn">get_key_value</a>&lt;Q&gt;(&amp;self, k: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;(<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;V</a>)&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Returns the key-value pair corresponding to the supplied key.</p>
<p>The supplied key may be any borrowed form of the map’s key type, but
<a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> and <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> on the borrowed form <em>must</em> match those for
the key type.</p>
<h5 id="examples-27"><a class="doc-anchor" href="#examples-27">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(map.get_key_value(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">Some</span>((<span class="kw-2">&amp;</span><span class="number">1</span>, <span class="kw-2">&amp;</span><span class="string">"a"</span>)));
<span class="macro">assert_eq!</span>(map.get_key_value(<span class="kw-2">&amp;</span><span class="number">2</span>), <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_key_value_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1387-1396">source</a><h4 class="code-header">pub fn <a href="#method.get_key_value_mut" class="fn">get_key_value_mut</a>&lt;Q&gt;(&amp;mut self, k: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;(<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>)&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Returns the key-value pair corresponding to the supplied key, with a mutable reference to value.</p>
<p>The supplied key may be any borrowed form of the map’s key type, but
<a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> and <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> on the borrowed form <em>must</em> match those for
the key type.</p>
<h5 id="examples-28"><a class="doc-anchor" href="#examples-28">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="kw">let </span>(k, v) = map.get_key_value_mut(<span class="kw-2">&amp;</span><span class="number">1</span>).unwrap();
<span class="macro">assert_eq!</span>(k, <span class="kw-2">&amp;</span><span class="number">1</span>);
<span class="macro">assert_eq!</span>(v, <span class="kw-2">&amp;mut </span><span class="string">"a"</span>);
<span class="kw-2">*</span>v = <span class="string">"b"</span>;
<span class="macro">assert_eq!</span>(map.get_key_value_mut(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">Some</span>((<span class="kw-2">&amp;</span><span class="number">1</span>, <span class="kw-2">&amp;mut </span><span class="string">"b"</span>)));
<span class="macro">assert_eq!</span>(map.get_key_value_mut(<span class="kw-2">&amp;</span><span class="number">2</span>), <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.contains_key" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1418-1423">source</a><h4 class="code-header">pub fn <a href="#method.contains_key" class="fn">contains_key</a>&lt;Q&gt;(&amp;self, k: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.bool.html">bool</a><div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Returns <code>true</code> if the map contains a value for the specified key.</p>
<p>The key may be any borrowed form of the map’s key type, but
<a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> and <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> on the borrowed form <em>must</em> match those for
the key type.</p>
<h5 id="examples-29"><a class="doc-anchor" href="#examples-29">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(map.contains_key(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="bool-val">true</span>);
<span class="macro">assert_eq!</span>(map.contains_key(<span class="kw-2">&amp;</span><span class="number">2</span>), <span class="bool-val">false</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1449-1458">source</a><h4 class="code-header">pub fn <a href="#method.get_mut" class="fn">get_mut</a>&lt;Q&gt;(&amp;mut self, k: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Returns a mutable reference to the value corresponding to the key.</p>
<p>The key may be any borrowed form of the map’s key type, but
<a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> and <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> on the borrowed form <em>must</em> match those for
the key type.</p>
<h5 id="examples-30"><a class="doc-anchor" href="#examples-30">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="kw">if let </span><span class="prelude-val">Some</span>(x) = map.get_mut(<span class="kw-2">&amp;</span><span class="number">1</span>) {
<span class="kw-2">*</span>x = <span class="string">"b"</span>;
}
<span class="macro">assert_eq!</span>(map[<span class="kw-2">&amp;</span><span class="number">1</span>], <span class="string">"b"</span>);
<span class="macro">assert_eq!</span>(map.get_mut(<span class="kw-2">&amp;</span><span class="number">2</span>), <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_many_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1516-1521">source</a><h4 class="code-header">pub fn <a href="#method.get_many_mut" class="fn">get_many_mut</a>&lt;Q, const N: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>&gt;(
&amp;mut self,
ks: [<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.array.html">N</a>],
) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;[<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.array.html">N</a>]&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Attempts to get mutable references to <code>N</code> values in the map at once.</p>
<p>Returns an array of length <code>N</code> with the results of each query. For soundness, at most one
mutable reference will be returned to any value. <code>None</code> will be returned if any of the
keys are duplicates or missing.</p>
<h5 id="examples-31"><a class="doc-anchor" href="#examples-31">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>libraries = HashMap::new();
libraries.insert(<span class="string">"Bodleian Library"</span>.to_string(), <span class="number">1602</span>);
libraries.insert(<span class="string">"Athenæum"</span>.to_string(), <span class="number">1807</span>);
libraries.insert(<span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>.to_string(), <span class="number">1691</span>);
libraries.insert(<span class="string">"Library of Congress"</span>.to_string(), <span class="number">1800</span>);
<span class="kw">let </span>got = libraries.get_many_mut([
<span class="string">"Athenæum"</span>,
<span class="string">"Library of Congress"</span>,
]);
<span class="macro">assert_eq!</span>(
got,
<span class="prelude-val">Some</span>([
<span class="kw-2">&amp;mut </span><span class="number">1807</span>,
<span class="kw-2">&amp;mut </span><span class="number">1800</span>,
]),
);
<span class="comment">// Missing keys result in None
</span><span class="kw">let </span>got = libraries.get_many_mut([
<span class="string">"Athenæum"</span>,
<span class="string">"New York Public Library"</span>,
]);
<span class="macro">assert_eq!</span>(got, <span class="prelude-val">None</span>);
<span class="comment">// Duplicate keys result in None
</span><span class="kw">let </span>got = libraries.get_many_mut([
<span class="string">"Athenæum"</span>,
<span class="string">"Athenæum"</span>,
]);
<span class="macro">assert_eq!</span>(got, <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_many_unchecked_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1568-1577">source</a><h4 class="code-header">pub unsafe fn <a href="#method.get_many_unchecked_mut" class="fn">get_many_unchecked_mut</a>&lt;Q, const N: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>&gt;(
&amp;mut self,
ks: [<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.array.html">N</a>],
) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;[<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.array.html">N</a>]&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Attempts to get mutable references to <code>N</code> values in the map at once, without validating that
the values are unique.</p>
<p>Returns an array of length <code>N</code> with the results of each query. <code>None</code> will be returned if
any of the keys are missing.</p>
<p>For a safe alternative see <a href="struct.HashMap.html#method.get_many_mut" title="method hashbrown::hash_map::HashMap::get_many_mut"><code>get_many_mut</code></a>.</p>
<h5 id="safety"><a class="doc-anchor" href="#safety">§</a>Safety</h5>
<p>Calling this method with overlapping keys is <em><a href="https://doc.rust-lang.org/reference/behavior-considered-undefined.html">undefined behavior</a></em> even if the resulting
references are not used.</p>
<h5 id="examples-32"><a class="doc-anchor" href="#examples-32">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>libraries = HashMap::new();
libraries.insert(<span class="string">"Bodleian Library"</span>.to_string(), <span class="number">1602</span>);
libraries.insert(<span class="string">"Athenæum"</span>.to_string(), <span class="number">1807</span>);
libraries.insert(<span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>.to_string(), <span class="number">1691</span>);
libraries.insert(<span class="string">"Library of Congress"</span>.to_string(), <span class="number">1800</span>);
<span class="kw">let </span>got = libraries.get_many_mut([
<span class="string">"Athenæum"</span>,
<span class="string">"Library of Congress"</span>,
]);
<span class="macro">assert_eq!</span>(
got,
<span class="prelude-val">Some</span>([
<span class="kw-2">&amp;mut </span><span class="number">1807</span>,
<span class="kw-2">&amp;mut </span><span class="number">1800</span>,
]),
);
<span class="comment">// Missing keys result in None
</span><span class="kw">let </span>got = libraries.get_many_mut([
<span class="string">"Athenæum"</span>,
<span class="string">"New York Public Library"</span>,
]);
<span class="macro">assert_eq!</span>(got, <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_many_key_value_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1623-1632">source</a><h4 class="code-header">pub fn <a href="#method.get_many_key_value_mut" class="fn">get_many_key_value_mut</a>&lt;Q, const N: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>&gt;(
&amp;mut self,
ks: [<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.array.html">N</a>],
) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;[(<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>); <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.array.html">N</a>]&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Attempts to get mutable references to <code>N</code> values in the map at once, with immutable
references to the corresponding keys.</p>
<p>Returns an array of length <code>N</code> with the results of each query. For soundness, at most one
mutable reference will be returned to any value. <code>None</code> will be returned if any of the keys
are duplicates or missing.</p>
<h5 id="examples-33"><a class="doc-anchor" href="#examples-33">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>libraries = HashMap::new();
libraries.insert(<span class="string">"Bodleian Library"</span>.to_string(), <span class="number">1602</span>);
libraries.insert(<span class="string">"Athenæum"</span>.to_string(), <span class="number">1807</span>);
libraries.insert(<span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>.to_string(), <span class="number">1691</span>);
libraries.insert(<span class="string">"Library of Congress"</span>.to_string(), <span class="number">1800</span>);
<span class="kw">let </span>got = libraries.get_many_key_value_mut([
<span class="string">"Bodleian Library"</span>,
<span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>,
]);
<span class="macro">assert_eq!</span>(
got,
<span class="prelude-val">Some</span>([
(<span class="kw-2">&amp;</span><span class="string">"Bodleian Library"</span>.to_string(), <span class="kw-2">&amp;mut </span><span class="number">1602</span>),
(<span class="kw-2">&amp;</span><span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>.to_string(), <span class="kw-2">&amp;mut </span><span class="number">1691</span>),
]),
);
<span class="comment">// Missing keys result in None
</span><span class="kw">let </span>got = libraries.get_many_key_value_mut([
<span class="string">"Bodleian Library"</span>,
<span class="string">"Gewandhaus"</span>,
]);
<span class="macro">assert_eq!</span>(got, <span class="prelude-val">None</span>);
<span class="comment">// Duplicate keys result in None
</span><span class="kw">let </span>got = libraries.get_many_key_value_mut([
<span class="string">"Bodleian Library"</span>,
<span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>,
<span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>,
]);
<span class="macro">assert_eq!</span>(got, <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.get_many_key_value_unchecked_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1678-1687">source</a><h4 class="code-header">pub unsafe fn <a href="#method.get_many_key_value_unchecked_mut" class="fn">get_many_key_value_unchecked_mut</a>&lt;Q, const N: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>&gt;(
&amp;mut self,
ks: [<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.array.html">N</a>],
) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;[(<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>); <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.array.html">N</a>]&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Attempts to get mutable references to <code>N</code> values in the map at once, with immutable
references to the corresponding keys, without validating that the values are unique.</p>
<p>Returns an array of length <code>N</code> with the results of each query. <code>None</code> will be returned if
any of the keys are missing.</p>
<p>For a safe alternative see <a href="struct.HashMap.html#method.get_many_key_value_mut" title="method hashbrown::hash_map::HashMap::get_many_key_value_mut"><code>get_many_key_value_mut</code></a>.</p>
<h5 id="safety-1"><a class="doc-anchor" href="#safety-1">§</a>Safety</h5>
<p>Calling this method with overlapping keys is <em><a href="https://doc.rust-lang.org/reference/behavior-considered-undefined.html">undefined behavior</a></em> even if the resulting
references are not used.</p>
<h5 id="examples-34"><a class="doc-anchor" href="#examples-34">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>libraries = HashMap::new();
libraries.insert(<span class="string">"Bodleian Library"</span>.to_string(), <span class="number">1602</span>);
libraries.insert(<span class="string">"Athenæum"</span>.to_string(), <span class="number">1807</span>);
libraries.insert(<span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>.to_string(), <span class="number">1691</span>);
libraries.insert(<span class="string">"Library of Congress"</span>.to_string(), <span class="number">1800</span>);
<span class="kw">let </span>got = libraries.get_many_key_value_mut([
<span class="string">"Bodleian Library"</span>,
<span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>,
]);
<span class="macro">assert_eq!</span>(
got,
<span class="prelude-val">Some</span>([
(<span class="kw-2">&amp;</span><span class="string">"Bodleian Library"</span>.to_string(), <span class="kw-2">&amp;mut </span><span class="number">1602</span>),
(<span class="kw-2">&amp;</span><span class="string">"Herzogin-Anna-Amalia-Bibliothek"</span>.to_string(), <span class="kw-2">&amp;mut </span><span class="number">1691</span>),
]),
);
<span class="comment">// Missing keys result in None
</span><span class="kw">let </span>got = libraries.get_many_key_value_mut([
<span class="string">"Bodleian Library"</span>,
<span class="string">"Gewandhaus"</span>,
]);
<span class="macro">assert_eq!</span>(got, <span class="prelude-val">None</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.insert" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1751-1766">source</a><h4 class="code-header">pub fn <a href="#method.insert" class="fn">insert</a>(&amp;mut self, k: K, v: V) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;V&gt;</h4></section></summary><div class="docblock"><p>Inserts a key-value pair into the map.</p>
<p>If the map did not have this key present, <a href="https://doc.rust-lang.org/std/option/enum.Option.html#variant.None"><code>None</code></a> is returned.</p>
<p>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 <code>==</code> without being identical. See the <a href="https://doc.rust-lang.org/std/collections/index.html"><code>std::collections</code></a>
<a href="https://doc.rust-lang.org/std/collections/index.html#insert-and-complex-keys">module-level documentation</a> for more.</p>
<h5 id="examples-35"><a class="doc-anchor" href="#examples-35">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
<span class="macro">assert_eq!</span>(map.insert(<span class="number">37</span>, <span class="string">"a"</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</span>(map.is_empty(), <span class="bool-val">false</span>);
map.insert(<span class="number">37</span>, <span class="string">"b"</span>);
<span class="macro">assert_eq!</span>(map.insert(<span class="number">37</span>, <span class="string">"c"</span>), <span class="prelude-val">Some</span>(<span class="string">"b"</span>));
<span class="macro">assert_eq!</span>(map[<span class="kw-2">&amp;</span><span class="number">37</span>], <span class="string">"c"</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.insert_unique_unchecked" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1818-1825">source</a><h4 class="code-header">pub fn <a href="#method.insert_unique_unchecked" class="fn">insert_unique_unchecked</a>(&amp;mut self, k: K, v: V) -&gt; (<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>)</h4></section></summary><div class="docblock"><p>Insert a key-value pair into the map without checking
if the key already exists in the map.</p>
<p>Returns a reference to the key and value just inserted.</p>
<p>This operation is safe if a key does not exist in the map.</p>
<p>However, if a key exists in the map already, the behavior is unspecified:
this operation may panic, loop forever, or any following operation with the map
may panic, loop forever or return arbitrary result.</p>
<p>That said, this operation (and following operations) are guaranteed to
not violate memory safety.</p>
<p>This operation is faster than regular insert, because it does not perform
lookup before insertion.</p>
<p>This operation is useful during initial population of the map.
For example, when constructing a map from another map, we know
that keys are unique.</p>
<h5 id="examples-36"><a class="doc-anchor" href="#examples-36">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map1 = HashMap::new();
<span class="macro">assert_eq!</span>(map1.insert(<span class="number">1</span>, <span class="string">"a"</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</span>(map1.insert(<span class="number">2</span>, <span class="string">"b"</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</span>(map1.insert(<span class="number">3</span>, <span class="string">"c"</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</span>(map1.len(), <span class="number">3</span>);
<span class="kw">let </span><span class="kw-2">mut </span>map2 = HashMap::new();
<span class="kw">for </span>(key, value) <span class="kw">in </span>map1.into_iter() {
map2.insert_unique_unchecked(key, value);
}
<span class="kw">let </span>(key, value) = map2.insert_unique_unchecked(<span class="number">4</span>, <span class="string">"d"</span>);
<span class="macro">assert_eq!</span>(key, <span class="kw-2">&amp;</span><span class="number">4</span>);
<span class="macro">assert_eq!</span>(value, <span class="kw-2">&amp;mut </span><span class="string">"d"</span>);
<span class="kw-2">*</span>value = <span class="string">"e"</span>;
<span class="macro">assert_eq!</span>(map2[<span class="kw-2">&amp;</span><span class="number">1</span>], <span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(map2[<span class="kw-2">&amp;</span><span class="number">2</span>], <span class="string">"b"</span>);
<span class="macro">assert_eq!</span>(map2[<span class="kw-2">&amp;</span><span class="number">3</span>], <span class="string">"c"</span>);
<span class="macro">assert_eq!</span>(map2[<span class="kw-2">&amp;</span><span class="number">4</span>], <span class="string">"e"</span>);
<span class="macro">assert_eq!</span>(map2.len(), <span class="number">4</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.try_insert" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1856-1865">source</a><h4 class="code-header">pub fn <a href="#method.try_insert" class="fn">try_insert</a>(
&amp;mut self,
key: K,
value: V,
) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut V</a>, <a class="struct" href="struct.OccupiedError.html" title="struct hashbrown::hash_map::OccupiedError">OccupiedError</a>&lt;'_, K, V, S, A&gt;&gt;</h4></section></summary><div class="docblock"><p>Tries to insert a key-value pair into the map, and returns
a mutable reference to the value in the entry.</p>
<h5 id="errors-1"><a class="doc-anchor" href="#errors-1">§</a>Errors</h5>
<p>If the map already had this key present, nothing is updated, and
an error containing the occupied entry and the value is returned.</p>
<h5 id="examples-37"><a class="doc-anchor" href="#examples-37">§</a>Examples</h5>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">use </span>hashbrown::hash_map::OccupiedError;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
<span class="macro">assert_eq!</span>(map.try_insert(<span class="number">37</span>, <span class="string">"a"</span>).unwrap(), <span class="kw-2">&amp;</span><span class="string">"a"</span>);
<span class="kw">match </span>map.try_insert(<span class="number">37</span>, <span class="string">"b"</span>) {
<span class="prelude-val">Err</span>(OccupiedError { entry, value }) =&gt; {
<span class="macro">assert_eq!</span>(entry.key(), <span class="kw-2">&amp;</span><span class="number">37</span>);
<span class="macro">assert_eq!</span>(entry.get(), <span class="kw-2">&amp;</span><span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(value, <span class="string">"b"</span>);
}
<span class="kw">_ </span>=&gt; <span class="macro">panic!</span>()
}</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.remove" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1895-1904">source</a><h4 class="code-header">pub fn <a href="#method.remove" class="fn">remove</a>&lt;Q&gt;(&amp;mut self, k: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;V&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Removes a key from the map, returning the value at the key if the key
was previously in the map. Keeps the allocated memory for reuse.</p>
<p>The key may be any borrowed form of the map’s key type, but
<a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> and <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> on the borrowed form <em>must</em> match those for
the key type.</p>
<h5 id="examples-38"><a class="doc-anchor" href="#examples-38">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
<span class="comment">// The map is empty
</span><span class="macro">assert!</span>(map.is_empty() &amp;&amp; map.capacity() == <span class="number">0</span>);
map.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(map.remove(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="string">"a"</span>));
<span class="macro">assert_eq!</span>(map.remove(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">None</span>);
<span class="comment">// Now map holds none elements
</span><span class="macro">assert!</span>(map.is_empty());</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.remove_entry" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1934-1940">source</a><h4 class="code-header">pub fn <a href="#method.remove_entry" class="fn">remove_entry</a>&lt;Q&gt;(&amp;mut self, k: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/option/enum.Option.html" title="enum core::option::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>&gt;<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h4></section></summary><div class="docblock"><p>Removes a key from the map, returning the stored key and value if the
key was previously in the map. Keeps the allocated memory for reuse.</p>
<p>The key may be any borrowed form of the map’s key type, but
<a href="https://doc.rust-lang.org/std/hash/trait.Hash.html"><code>Hash</code></a> and <a href="https://doc.rust-lang.org/std/cmp/trait.Eq.html"><code>Eq</code></a> on the borrowed form <em>must</em> match those for
the key type.</p>
<h5 id="examples-39"><a class="doc-anchor" href="#examples-39">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
<span class="comment">// The map is empty
</span><span class="macro">assert!</span>(map.is_empty() &amp;&amp; map.capacity() == <span class="number">0</span>);
map.insert(<span class="number">1</span>, <span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(map.remove_entry(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="string">"a"</span>)));
<span class="macro">assert_eq!</span>(map.remove(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">None</span>);
<span class="comment">// Now map hold none elements
</span><span class="macro">assert!</span>(map.is_empty());</code></pre></div>
</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-HashMap%3CK,+V,+S,+A%3E-2" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#1943-2167">source</a><a href="#impl-HashMap%3CK,+V,+S,+A%3E-2" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A: Allocator&gt; <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.raw_entry_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2042-2044">source</a><h4 class="code-header">pub fn <a href="#method.raw_entry_mut" class="fn">raw_entry_mut</a>(&amp;mut self) -&gt; <a class="struct" href="struct.RawEntryBuilderMut.html" title="struct hashbrown::hash_map::RawEntryBuilderMut">RawEntryBuilderMut</a>&lt;'_, K, V, S, A&gt;</h4></section></summary><div class="docblock"><p>Creates a raw entry builder for the HashMap.</p>
<p>Raw entries provide the lowest level of control for searching and
manipulating a map. They must be manually initialized with a hash and
then manually searched. After this, insertions into a vacant entry
still require an owned key to be provided.</p>
<p>Raw entries are useful for such exotic situations as:</p>
<ul>
<li>Hash memoization</li>
<li>Deferring the creation of an owned key until it is known to be required</li>
<li>Using a search key that doesn’t work with the Borrow trait</li>
<li>Using custom comparison logic without newtype wrappers</li>
</ul>
<p>Because raw entries provide much more low-level control, it’s much easier
to put the HashMap into an inconsistent state which, while memory-safe,
will cause the map to produce seemingly random results. Higher-level and
more foolproof APIs like <code>entry</code> should be preferred when possible.</p>
<p>In particular, the hash used to initialized the raw entry must still be
consistent with the hash of the key that is ultimately stored in the entry.
This is because implementations of HashMap may need to recompute hashes
when resizing, at which point only the keys are available.</p>
<p>Raw entries give mutable access to the keys. This must not be used
to modify how the key would compare or hash, as the map will not re-evaluate
where the key should go, meaning the keys may become “lost” if their
location does not reflect their state. For instance, if you change a key
so that the map now contains keys which compare equal, search may start
acting erratically, with two keys randomly masking each other. Implementations
are free to assume this doesn’t happen (within the limits of memory-safety).</p>
<h5 id="examples-40"><a class="doc-anchor" href="#examples-40">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>core::hash::{BuildHasher, Hash};
<span class="kw">use </span>hashbrown::hash_map::{HashMap, RawEntryMut};
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.extend([(<span class="string">"a"</span>, <span class="number">100</span>), (<span class="string">"b"</span>, <span class="number">200</span>), (<span class="string">"c"</span>, <span class="number">300</span>)]);
<span class="kw">fn </span>compute_hash&lt;K: Hash + <span class="question-mark">?</span>Sized, S: BuildHasher&gt;(hash_builder: <span class="kw-2">&amp;</span>S, key: <span class="kw-2">&amp;</span>K) -&gt; u64 {
<span class="kw">use </span>core::hash::Hasher;
<span class="kw">let </span><span class="kw-2">mut </span>state = hash_builder.build_hasher();
key.hash(<span class="kw-2">&amp;mut </span>state);
state.finish()
}
<span class="comment">// Existing key (insert and update)
</span><span class="kw">match </span>map.raw_entry_mut().from_key(<span class="kw-2">&amp;</span><span class="string">"a"</span>) {
RawEntryMut::Vacant(<span class="kw">_</span>) =&gt; <span class="macro">unreachable!</span>(),
RawEntryMut::Occupied(<span class="kw-2">mut </span>view) =&gt; {
<span class="macro">assert_eq!</span>(view.get(), <span class="kw-2">&amp;</span><span class="number">100</span>);
<span class="kw">let </span>v = view.get_mut();
<span class="kw">let </span>new_v = (<span class="kw-2">*</span>v) * <span class="number">10</span>;
<span class="kw-2">*</span>v = new_v;
<span class="macro">assert_eq!</span>(view.insert(<span class="number">1111</span>), <span class="number">1000</span>);
}
}
<span class="macro">assert_eq!</span>(map[<span class="kw-2">&amp;</span><span class="string">"a"</span>], <span class="number">1111</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);
<span class="comment">// Existing key (take)
</span><span class="kw">let </span>hash = compute_hash(map.hasher(), <span class="kw-2">&amp;</span><span class="string">"c"</span>);
<span class="kw">match </span>map.raw_entry_mut().from_key_hashed_nocheck(hash, <span class="kw-2">&amp;</span><span class="string">"c"</span>) {
RawEntryMut::Vacant(<span class="kw">_</span>) =&gt; <span class="macro">unreachable!</span>(),
RawEntryMut::Occupied(view) =&gt; {
<span class="macro">assert_eq!</span>(view.remove_entry(), (<span class="string">"c"</span>, <span class="number">300</span>));
}
}
<span class="macro">assert_eq!</span>(map.raw_entry().from_key(<span class="kw-2">&amp;</span><span class="string">"c"</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">2</span>);
<span class="comment">// Nonexistent key (insert and update)
</span><span class="kw">let </span>key = <span class="string">"d"</span>;
<span class="kw">let </span>hash = compute_hash(map.hasher(), <span class="kw-2">&amp;</span>key);
<span class="kw">match </span>map.raw_entry_mut().from_hash(hash, |q| <span class="kw-2">*</span>q == key) {
RawEntryMut::Occupied(<span class="kw">_</span>) =&gt; <span class="macro">unreachable!</span>(),
RawEntryMut::Vacant(view) =&gt; {
<span class="kw">let </span>(k, value) = view.insert(<span class="string">"d"</span>, <span class="number">4000</span>);
<span class="macro">assert_eq!</span>((<span class="kw-2">*</span>k, <span class="kw-2">*</span>value), (<span class="string">"d"</span>, <span class="number">4000</span>));
<span class="kw-2">*</span>value = <span class="number">40000</span>;
}
}
<span class="macro">assert_eq!</span>(map[<span class="kw-2">&amp;</span><span class="string">"d"</span>], <span class="number">40000</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);
<span class="kw">match </span>map.raw_entry_mut().from_hash(hash, |q| <span class="kw-2">*</span>q == key) {
RawEntryMut::Vacant(<span class="kw">_</span>) =&gt; <span class="macro">unreachable!</span>(),
RawEntryMut::Occupied(view) =&gt; {
<span class="macro">assert_eq!</span>(view.remove_entry(), (<span class="string">"d"</span>, <span class="number">40000</span>));
}
}
<span class="macro">assert_eq!</span>(map.get(<span class="kw-2">&amp;</span><span class="string">"d"</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">2</span>);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.raw_entry" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2091-2093">source</a><h4 class="code-header">pub fn <a href="#method.raw_entry" class="fn">raw_entry</a>(&amp;self) -&gt; <a class="struct" href="struct.RawEntryBuilder.html" title="struct hashbrown::hash_map::RawEntryBuilder">RawEntryBuilder</a>&lt;'_, K, V, S, A&gt;</h4></section></summary><div class="docblock"><p>Creates a raw immutable entry builder for the HashMap.</p>
<p>Raw entries provide the lowest level of control for searching and
manipulating a map. They must be manually initialized with a hash and
then manually searched.</p>
<p>This is useful for</p>
<ul>
<li>Hash memoization</li>
<li>Using a search key that doesn’t work with the Borrow trait</li>
<li>Using custom comparison logic without newtype wrappers</li>
</ul>
<p>Unless you are in such a situation, higher-level and more foolproof APIs like
<code>get</code> should be preferred.</p>
<p>Immutable raw entries have very limited use; you might instead want <code>raw_entry_mut</code>.</p>
<h5 id="examples-41"><a class="doc-anchor" href="#examples-41">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>core::hash::{BuildHasher, Hash};
<span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.extend([(<span class="string">"a"</span>, <span class="number">100</span>), (<span class="string">"b"</span>, <span class="number">200</span>), (<span class="string">"c"</span>, <span class="number">300</span>)]);
<span class="kw">fn </span>compute_hash&lt;K: Hash + <span class="question-mark">?</span>Sized, S: BuildHasher&gt;(hash_builder: <span class="kw-2">&amp;</span>S, key: <span class="kw-2">&amp;</span>K) -&gt; u64 {
<span class="kw">use </span>core::hash::Hasher;
<span class="kw">let </span><span class="kw-2">mut </span>state = hash_builder.build_hasher();
key.hash(<span class="kw-2">&amp;mut </span>state);
state.finish()
}
<span class="kw">for </span>k <span class="kw">in </span>[<span class="string">"a"</span>, <span class="string">"b"</span>, <span class="string">"c"</span>, <span class="string">"d"</span>, <span class="string">"e"</span>, <span class="string">"f"</span>] {
<span class="kw">let </span>hash = compute_hash(map.hasher(), k);
<span class="kw">let </span>v = map.get(<span class="kw-2">&amp;</span>k).cloned();
<span class="kw">let </span>kv = v.as_ref().map(|v| (<span class="kw-2">&amp;</span>k, v));
<span class="macro">println!</span>(<span class="string">"Key: {} and value: {:?}"</span>, k, v);
<span class="macro">assert_eq!</span>(map.raw_entry().from_key(<span class="kw-2">&amp;</span>k), kv);
<span class="macro">assert_eq!</span>(map.raw_entry().from_hash(hash, |q| <span class="kw-2">*</span>q == k), kv);
<span class="macro">assert_eq!</span>(map.raw_entry().from_key_hashed_nocheck(hash, <span class="kw-2">&amp;</span>k), kv);
}</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.raw_table" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2103-2105">source</a><h4 class="code-header">pub fn <a href="#method.raw_table" class="fn">raw_table</a>(&amp;self) -&gt; &amp;<a class="struct" href="../raw/struct.RawTable.html" title="struct hashbrown::raw::RawTable">RawTable</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>, A&gt;</h4></section></summary><div class="docblock"><p>Returns a reference to the <a href="../raw/struct.RawTable.html" title="struct hashbrown::raw::RawTable"><code>RawTable</code></a> used underneath <a href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap"><code>HashMap</code></a>.
This function is only available if the <code>raw</code> feature of the crate is enabled.</p>
<p>See <a href="struct.HashMap.html#method.raw_table_mut" title="method hashbrown::hash_map::HashMap::raw_table_mut"><code>raw_table_mut</code></a> for more.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.raw_table_mut" class="method"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2164-2166">source</a><h4 class="code-header">pub fn <a href="#method.raw_table_mut" class="fn">raw_table_mut</a>(&amp;mut self) -&gt; &amp;mut <a class="struct" href="../raw/struct.RawTable.html" title="struct hashbrown::raw::RawTable">RawTable</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>, A&gt;</h4></section></summary><div class="docblock"><p>Returns a mutable reference to the <a href="../raw/struct.RawTable.html" title="struct hashbrown::raw::RawTable"><code>RawTable</code></a> used underneath <a href="struct.HashMap.html"><code>HashMap</code></a>.
This function is only available if the <code>raw</code> feature of the crate is enabled.</p>
<h5 id="note"><a class="doc-anchor" href="#note">§</a>Note</h5>
<p>Calling this function is safe, but using the raw hash table API may require
unsafe functions or blocks.</p>
<p><code>RawTable</code> API gives the lowest level of control under the map that can be useful
for extending the HashMap’s API, but may lead to <em><a href="https://doc.rust-lang.org/reference/behavior-considered-undefined.html">undefined behavior</a></em>.</p>
<h5 id="examples-42"><a class="doc-anchor" href="#examples-42">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>core::hash::{BuildHasher, Hash};
<span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.extend([(<span class="string">"a"</span>, <span class="number">10</span>), (<span class="string">"b"</span>, <span class="number">20</span>), (<span class="string">"c"</span>, <span class="number">30</span>)]);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">3</span>);
<span class="comment">// Let's imagine that we have a value and a hash of the key, but not the key itself.
// However, if you want to remove the value from the map by hash and value, and you
// know exactly that the value is unique, then you can create a function like this:
</span><span class="kw">fn </span>remove_by_hash&lt;K, V, S, F&gt;(
map: <span class="kw-2">&amp;mut </span>HashMap&lt;K, V, S&gt;,
hash: u64,
is_match: F,
) -&gt; <span class="prelude-ty">Option</span>&lt;(K, V)&gt;
<span class="kw">where
</span>F: Fn(<span class="kw-2">&amp;</span>(K, V)) -&gt; bool,
{
<span class="kw">let </span>raw_table = map.raw_table_mut();
<span class="kw">match </span>raw_table.find(hash, is_match) {
<span class="prelude-val">Some</span>(bucket) =&gt; <span class="prelude-val">Some</span>(<span class="kw">unsafe </span>{ raw_table.remove(bucket).<span class="number">0 </span>}),
<span class="prelude-val">None </span>=&gt; <span class="prelude-val">None</span>,
}
}
<span class="kw">fn </span>compute_hash&lt;K: Hash + <span class="question-mark">?</span>Sized, S: BuildHasher&gt;(hash_builder: <span class="kw-2">&amp;</span>S, key: <span class="kw-2">&amp;</span>K) -&gt; u64 {
<span class="kw">use </span>core::hash::Hasher;
<span class="kw">let </span><span class="kw-2">mut </span>state = hash_builder.build_hasher();
key.hash(<span class="kw-2">&amp;mut </span>state);
state.finish()
}
<span class="kw">let </span>hash = compute_hash(map.hasher(), <span class="string">"a"</span>);
<span class="macro">assert_eq!</span>(remove_by_hash(<span class="kw-2">&amp;mut </span>map, hash, |(<span class="kw">_</span>, v)| <span class="kw-2">*</span>v == <span class="number">10</span>), <span class="prelude-val">Some</span>((<span class="string">"a"</span>, <span class="number">10</span>)));
<span class="macro">assert_eq!</span>(map.get(<span class="kw-2">&amp;</span><span class="string">"a"</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</span>(map.len(), <span class="number">2</span>);</code></pre></div>
</div></details></div></details></div><h2 id="trait-implementations" class="section-header">Trait Implementations<a href="#trait-implementations" class="anchor">§</a></h2><div id="trait-implementations-list"><details class="toggle implementors-toggle" open><summary><section id="impl-Clone-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#195-209">source</a><a href="#impl-Clone-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, A: Allocator + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.clone" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#196-201">source</a><a href="#method.clone" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html#tymethod.clone" class="fn">clone</a>(&amp;self) -&gt; Self</h4></section></summary><div class='docblock'>Returns a copy of the value. <a href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html#tymethod.clone">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.clone_from" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#203-208">source</a><a href="#method.clone_from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html#method.clone_from" class="fn">clone_from</a>(&amp;mut self, source: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Self</a>)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html#method.clone_from">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Debug-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2195-2204">source</a><a href="#impl-Debug-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a>,
A: Allocator,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.fmt" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2201-2203">source</a><a href="#method.fmt" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/fmt/trait.Debug.html#tymethod.fmt" class="fn">fmt</a>(&amp;self, f: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.80.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>&lt;'_&gt;) -&gt; <a class="type" href="https://doc.rust-lang.org/1.80.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/1.80.0/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Default-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2206-2230">source</a><a href="#impl-Default-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>,
A: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a> + Allocator,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.default" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2227-2229">source</a><a href="#method.default" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/default/trait.Default.html#tymethod.default" class="fn">default</a>() -&gt; Self</h4></section></summary><div class="docblock"><p>Creates an empty <code>HashMap&lt;K, V, S, A&gt;</code>, with the <code>Default</code> value for the hasher and allocator.</p>
<h5 id="examples-44"><a class="doc-anchor" href="#examples-44">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">use </span>std::collections::hash_map::RandomState;
<span class="comment">// You can specify all types of HashMap, including hasher and allocator.
// Created map is empty and don't allocate memory
</span><span class="kw">let </span>map: HashMap&lt;u32, String&gt; = Default::default();
<span class="macro">assert_eq!</span>(map.capacity(), <span class="number">0</span>);
<span class="kw">let </span>map: HashMap&lt;u32, String, RandomState&gt; = HashMap::default();
<span class="macro">assert_eq!</span>(map.capacity(), <span class="number">0</span>);</code></pre></div>
</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Extend%3C%26(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#6605-6661">source</a><a href="#impl-Extend%3C%26(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'a, K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html" title="trait core::iter::traits::collect::Extend">Extend</a>&lt;&amp;'a <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>&gt; for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>,
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.BuildHasher.html" title="trait core::hash::BuildHasher">BuildHasher</a>,
A: Allocator,</div></h3></section></summary><div class="docblock"><p>Inserts all new key-values from the iterator and replaces values with existing
keys with new values returned from the iterator.</p>
</div><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.extend-1" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#6646-6648">source</a><a href="#method.extend-1" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#tymethod.extend" class="fn">extend</a>&lt;T: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a>&lt;Item = &amp;'a <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>&gt;&gt;(&amp;mut self, iter: T)</h4></section></summary><div class="docblock"><p>Inserts all new key-values from the iterator to existing <code>HashMap&lt;K, V, S, A&gt;</code>.
Replace values with existing keys with new values returned from the iterator.
The keys and values must implement <a href="https://doc.rust-lang.org/core/marker/trait.Copy.html"><code>Copy</code></a> trait.</p>
<h5 id="examples-46"><a class="doc-anchor" href="#examples-46">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::hash_map::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="number">1</span>, <span class="number">100</span>);
<span class="kw">let </span>arr = [(<span class="number">1</span>, <span class="number">1</span>), (<span class="number">2</span>, <span class="number">2</span>)];
<span class="kw">let </span>some_iter = arr.iter();
map.extend(some_iter);
<span class="comment">// Replace values with existing keys with new values returned from the iterator.
// So that the map.get(&amp;1) doesn't return Some(&amp;100).
</span><span class="macro">assert_eq!</span>(map.get(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">1</span>));
<span class="kw">let </span>some_vec: Vec&lt;<span class="kw">_</span>&gt; = <span class="macro">vec!</span>[(<span class="number">3</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">4</span>)];
map.extend(<span class="kw-2">&amp;</span>some_vec);
<span class="kw">let </span>some_arr = [(<span class="number">5</span>, <span class="number">5</span>), (<span class="number">6</span>, <span class="number">6</span>)];
map.extend(<span class="kw-2">&amp;</span>some_arr);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;<span class="kw">_</span>&gt; = map.into_iter().collect();
<span class="comment">// The `IntoIter` iterator produces items in arbitrary order, so the
// items must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [(<span class="number">1</span>, <span class="number">1</span>), (<span class="number">2</span>, <span class="number">2</span>), (<span class="number">3</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">4</span>), (<span class="number">5</span>, <span class="number">5</span>), (<span class="number">6</span>, <span class="number">6</span>)]);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.extend_one-1" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/iter/traits/collect.rs.html#453">source</a><a href="#method.extend_one-1" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_one" class="fn">extend_one</a>(&amp;mut self, item: A)</h4></section></summary><span class="item-info"><div class="stab unstable"><span class="emoji">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class="toggle method-toggle" open><summary><section id="method.extend_reserve-1" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/iter/traits/collect.rs.html#461">source</a><a href="#method.extend_reserve-1" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_reserve" class="fn">extend_reserve</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>)</h4></section></summary><span class="item-info"><div class="stab unstable"><span class="emoji">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_reserve">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Extend%3C(%26K,+%26V)%3E-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#6540-6601">source</a><a href="#impl-Extend%3C(%26K,+%26V)%3E-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'a, K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html" title="trait core::iter::traits::collect::Extend">Extend</a>&lt;(<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'a K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'a V</a>)&gt; for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>,
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.BuildHasher.html" title="trait core::hash::BuildHasher">BuildHasher</a>,
A: Allocator,</div></h3></section></summary><div class="docblock"><p>Inserts all new key-values from the iterator and replaces values with existing
keys with new values returned from the iterator.</p>
</div><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.extend" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#6586-6588">source</a><a href="#method.extend" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#tymethod.extend" class="fn">extend</a>&lt;T: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a>&lt;Item = (<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'a K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'a V</a>)&gt;&gt;(&amp;mut self, iter: T)</h4></section></summary><div class="docblock"><p>Inserts all new key-values from the iterator to existing <code>HashMap&lt;K, V, S, A&gt;</code>.
Replace values with existing keys with new values returned from the iterator.
The keys and values must implement <a href="https://doc.rust-lang.org/core/marker/trait.Copy.html"><code>Copy</code></a> trait.</p>
<h5 id="examples-45"><a class="doc-anchor" href="#examples-45">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::hash_map::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="number">1</span>, <span class="number">100</span>);
<span class="kw">let </span>arr = [(<span class="number">1</span>, <span class="number">1</span>), (<span class="number">2</span>, <span class="number">2</span>)];
<span class="kw">let </span>some_iter = arr.iter().map(|(k, v)| (k, v));
map.extend(some_iter);
<span class="comment">// Replace values with existing keys with new values returned from the iterator.
// So that the map.get(&amp;1) doesn't return Some(&amp;100).
</span><span class="macro">assert_eq!</span>(map.get(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">1</span>));
<span class="kw">let </span>some_vec: Vec&lt;<span class="kw">_</span>&gt; = <span class="macro">vec!</span>[(<span class="number">3</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">4</span>)];
map.extend(some_vec.iter().map(|(k, v)| (k, v)));
<span class="kw">let </span>some_arr = [(<span class="number">5</span>, <span class="number">5</span>), (<span class="number">6</span>, <span class="number">6</span>)];
map.extend(some_arr.iter().map(|(k, v)| (k, v)));
<span class="comment">// You can also extend from another HashMap
</span><span class="kw">let </span><span class="kw-2">mut </span>new_map = HashMap::new();
new_map.extend(<span class="kw-2">&amp;</span>map);
<span class="macro">assert_eq!</span>(new_map, map);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;<span class="kw">_</span>&gt; = new_map.into_iter().collect();
<span class="comment">// The `IntoIter` iterator produces items in arbitrary order, so the
// items must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [(<span class="number">1</span>, <span class="number">1</span>), (<span class="number">2</span>, <span class="number">2</span>), (<span class="number">3</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">4</span>), (<span class="number">5</span>, <span class="number">5</span>), (<span class="number">6</span>, <span class="number">6</span>)]);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.extend_one" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/iter/traits/collect.rs.html#453">source</a><a href="#method.extend_one" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_one" class="fn">extend_one</a>(&amp;mut self, item: A)</h4></section></summary><span class="item-info"><div class="stab unstable"><span class="emoji">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class="toggle method-toggle" open><summary><section id="method.extend_reserve" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/iter/traits/collect.rs.html#461">source</a><a href="#method.extend_reserve" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_reserve" class="fn">extend_reserve</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>)</h4></section></summary><span class="item-info"><div class="stab unstable"><span class="emoji">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_reserve">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Extend%3C(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#6457-6536">source</a><a href="#impl-Extend%3C(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html" title="trait core::iter::traits::collect::Extend">Extend</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>&gt; for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>,
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.BuildHasher.html" title="trait core::hash::BuildHasher">BuildHasher</a>,
A: Allocator,</div></h3></section></summary><div class="docblock"><p>Inserts all new key-values from the iterator and replaces values with existing
keys with new values returned from the iterator.</p>
</div><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.extend-2" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#6499-6514">source</a><a href="#method.extend-2" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#tymethod.extend" class="fn">extend</a>&lt;T: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a>&lt;Item = <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>&gt;&gt;(&amp;mut self, iter: T)</h4></section></summary><div class="docblock"><p>Inserts all new key-values from the iterator to existing <code>HashMap&lt;K, V, S, A&gt;</code>.
Replace values with existing keys with new values returned from the iterator.</p>
<h5 id="examples-47"><a class="doc-anchor" href="#examples-47">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::hash_map::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map = HashMap::new();
map.insert(<span class="number">1</span>, <span class="number">100</span>);
<span class="kw">let </span>some_iter = [(<span class="number">1</span>, <span class="number">1</span>), (<span class="number">2</span>, <span class="number">2</span>)].into_iter();
map.extend(some_iter);
<span class="comment">// Replace values with existing keys with new values returned from the iterator.
// So that the map.get(&amp;1) doesn't return Some(&amp;100).
</span><span class="macro">assert_eq!</span>(map.get(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">1</span>));
<span class="kw">let </span>some_vec: Vec&lt;<span class="kw">_</span>&gt; = <span class="macro">vec!</span>[(<span class="number">3</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">4</span>)];
map.extend(some_vec);
<span class="kw">let </span>some_arr = [(<span class="number">5</span>, <span class="number">5</span>), (<span class="number">6</span>, <span class="number">6</span>)];
map.extend(some_arr);
<span class="kw">let </span>old_map_len = map.len();
<span class="comment">// You can also extend from another HashMap
</span><span class="kw">let </span><span class="kw-2">mut </span>new_map = HashMap::new();
new_map.extend(map);
<span class="macro">assert_eq!</span>(new_map.len(), old_map_len);
<span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;<span class="kw">_</span>&gt; = new_map.into_iter().collect();
<span class="comment">// The `IntoIter` iterator produces items in arbitrary order, so the
// items must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [(<span class="number">1</span>, <span class="number">1</span>), (<span class="number">2</span>, <span class="number">2</span>), (<span class="number">3</span>, <span class="number">3</span>), (<span class="number">4</span>, <span class="number">4</span>), (<span class="number">5</span>, <span class="number">5</span>), (<span class="number">6</span>, <span class="number">6</span>)]);</code></pre></div>
</div></details><details class="toggle method-toggle" open><summary><section id="method.extend_one-2" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/iter/traits/collect.rs.html#453">source</a><a href="#method.extend_one-2" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_one" class="fn">extend_one</a>(&amp;mut self, item: A)</h4></section></summary><span class="item-info"><div class="stab unstable"><span class="emoji">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Extends a collection with exactly one element.</div></details><details class="toggle method-toggle" open><summary><section id="method.extend_reserve-2" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/iter/traits/collect.rs.html#461">source</a><a href="#method.extend_reserve-2" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_reserve" class="fn">extend_reserve</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.usize.html">usize</a>)</h4></section></summary><span class="item-info"><div class="stab unstable"><span class="emoji">🔬</span><span>This is a nightly-only experimental API. (<code>extend_one</code>)</span></div></span><div class='docblock'>Reserves capacity in a collection for the given number of additional elements. <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.Extend.html#method.extend_reserve">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-From%3CHashMap%3CT,+(),+S,+A%3E%3E-for-HashSet%3CT,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/set.rs.html#1303-1310">source</a><a href="#impl-From%3CHashMap%3CT,+(),+S,+A%3E%3E-for-HashSet%3CT,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;<a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;T, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.unit.html">()</a>, S, A&gt;&gt; for <a class="struct" href="../hash_set/struct.HashSet.html" title="struct hashbrown::hash_set::HashSet">HashSet</a>&lt;T, S, A&gt;<div class="where">where
A: Allocator,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.from" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/set.rs.html#1307-1309">source</a><a href="#method.from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.From.html#tymethod.from" class="fn">from</a>(map: <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;T, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.unit.html">()</a>, S, A&gt;) -&gt; Self</h4></section></summary><div class='docblock'>Converts to this type from the input type.</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-FromIterator%3C(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#6437-6453">source</a><a href="#impl-FromIterator%3C(K,+V)%3E-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.FromIterator.html" title="trait core::iter::traits::collect::FromIterator">FromIterator</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>&gt; for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>,
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.BuildHasher.html" title="trait core::hash::BuildHasher">BuildHasher</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>,
A: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a> + Allocator,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.from_iter" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#6444-6452">source</a><a href="#method.from_iter" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter" class="fn">from_iter</a>&lt;T: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a>&lt;Item = <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a>&gt;&gt;(iter: T) -&gt; Self</h4></section></summary><div class='docblock'>Creates a value from an iterator. <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Index%3C%26Q%3E-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2232-2261">source</a><a href="#impl-Index%3C%26Q%3E-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, Q, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/ops/index/trait.Index.html" title="trait core::ops::index::Index">Index</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>&gt; for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>,
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> + <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.BuildHasher.html" title="trait core::hash::BuildHasher">BuildHasher</a>,
A: Allocator,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.index" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2258-2260">source</a><a href="#method.index" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/ops/index/trait.Index.html#tymethod.index" class="fn">index</a>(&amp;self, key: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Q</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;V</a></h4></section></summary><div class="docblock"><p>Returns a reference to the value corresponding to the supplied key.</p>
<h5 id="panics-1"><a class="doc-anchor" href="#panics-1">§</a>Panics</h5>
<p>Panics if the key is not present in the <code>HashMap</code>.</p>
<h5 id="examples-49"><a class="doc-anchor" href="#examples-49">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span>map: HashMap&lt;<span class="kw">_</span>, <span class="kw">_</span>&gt; = [(<span class="string">"a"</span>, <span class="string">"One"</span>), (<span class="string">"b"</span>, <span class="string">"Two"</span>)].into();
<span class="macro">assert_eq!</span>(map[<span class="kw-2">&amp;</span><span class="string">"a"</span>], <span class="string">"One"</span>);
<span class="macro">assert_eq!</span>(map[<span class="kw-2">&amp;</span><span class="string">"b"</span>], <span class="string">"Two"</span>);</code></pre></div>
</div></details><details class="toggle" open><summary><section id="associatedtype.Output" class="associatedtype trait-impl"><a href="#associatedtype.Output" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/ops/index/trait.Index.html#associatedtype.Output" class="associatedtype">Output</a> = V</h4></section></summary><div class='docblock'>The returned type after indexing.</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-IntoIterator-for-%26HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#4624-4654">source</a><a href="#impl-IntoIterator-for-%26HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'a, K, V, S, A: Allocator&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for &amp;'a <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.into_iter-2" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#4651-4653">source</a><a href="#method.into_iter-2" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter" class="fn">into_iter</a>(self) -&gt; <a class="struct" href="struct.Iter.html" title="struct hashbrown::hash_map::Iter">Iter</a>&lt;'a, K, V&gt; <a href="#" class="tooltip" data-notable-ty="Iter&lt;&#39;a, K, V&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>Creates an iterator over the entries of a <code>HashMap</code> in arbitrary order.
The iterator element type is <code>(&amp;'a K, &amp;'a V)</code>.</p>
<p>Return the same <code>Iter</code> struct as by the <a href="struct.HashMap.html#method.iter"><code>iter</code></a> method on <a href="struct.HashMap.html"><code>HashMap</code></a>.</p>
<h5 id="examples-50"><a class="doc-anchor" href="#examples-50">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span>map_one: HashMap&lt;<span class="kw">_</span>, <span class="kw">_</span>&gt; = [(<span class="number">1</span>, <span class="string">"a"</span>), (<span class="number">2</span>, <span class="string">"b"</span>), (<span class="number">3</span>, <span class="string">"c"</span>)].into();
<span class="kw">let </span><span class="kw-2">mut </span>map_two = HashMap::new();
<span class="kw">for </span>(key, value) <span class="kw">in </span><span class="kw-2">&amp;</span>map_one {
<span class="macro">println!</span>(<span class="string">"Key: {}, Value: {}"</span>, key, value);
map_two.insert_unique_unchecked(<span class="kw-2">*</span>key, <span class="kw-2">*</span>value);
}
<span class="macro">assert_eq!</span>(map_one, map_two);</code></pre></div>
</div></details><details class="toggle" open><summary><section id="associatedtype.Item-2" class="associatedtype trait-impl"><a href="#associatedtype.Item-2" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item" class="associatedtype">Item</a> = (<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'a K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'a V</a>)</h4></section></summary><div class='docblock'>The type of the elements being iterated over.</div></details><details class="toggle" open><summary><section id="associatedtype.IntoIter-2" class="associatedtype trait-impl"><a href="#associatedtype.IntoIter-2" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" class="associatedtype">IntoIter</a> = <a class="struct" href="struct.Iter.html" title="struct hashbrown::hash_map::Iter">Iter</a>&lt;'a, K, V&gt;</h4></section></summary><div class='docblock'>Which kind of iterator are we turning this into?</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-IntoIterator-for-%26mut+HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#4656-4691">source</a><a href="#impl-IntoIterator-for-%26mut+HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;'a, K, V, S, A: Allocator&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for &amp;'a mut <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.into_iter-1" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#4688-4690">source</a><a href="#method.into_iter-1" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter" class="fn">into_iter</a>(self) -&gt; <a class="struct" href="struct.IterMut.html" title="struct hashbrown::hash_map::IterMut">IterMut</a>&lt;'a, K, V&gt; <a href="#" class="tooltip" data-notable-ty="IterMut&lt;&#39;a, K, V&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>Creates an iterator over the entries of a <code>HashMap</code> in arbitrary order
with mutable references to the values. The iterator element type is
<code>(&amp;'a K, &amp;'a mut V)</code>.</p>
<p>Return the same <code>IterMut</code> struct as by the <a href="struct.HashMap.html#method.iter_mut"><code>iter_mut</code></a> method on
<a href="struct.HashMap.html"><code>HashMap</code></a>.</p>
<h5 id="examples-48"><a class="doc-anchor" href="#examples-48">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span><span class="kw-2">mut </span>map: HashMap&lt;<span class="kw">_</span>, <span class="kw">_</span>&gt; = [(<span class="string">"a"</span>, <span class="number">1</span>), (<span class="string">"b"</span>, <span class="number">2</span>), (<span class="string">"c"</span>, <span class="number">3</span>)].into();
<span class="kw">for </span>(key, value) <span class="kw">in </span><span class="kw-2">&amp;mut </span>map {
<span class="macro">println!</span>(<span class="string">"Key: {}, Value: {}"</span>, key, value);
<span class="kw-2">*</span>value <span class="kw-2">*</span>= <span class="number">2</span>;
}
<span class="kw">let </span><span class="kw-2">mut </span>vec = map.iter().collect::&lt;Vec&lt;<span class="kw">_</span>&gt;&gt;();
<span class="comment">// The `Iter` iterator produces items in arbitrary order, so the
// items must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [(<span class="kw-2">&amp;</span><span class="string">"a"</span>, <span class="kw-2">&amp;</span><span class="number">2</span>), (<span class="kw-2">&amp;</span><span class="string">"b"</span>, <span class="kw-2">&amp;</span><span class="number">4</span>), (<span class="kw-2">&amp;</span><span class="string">"c"</span>, <span class="kw-2">&amp;</span><span class="number">6</span>)]);</code></pre></div>
</div></details><details class="toggle" open><summary><section id="associatedtype.Item-1" class="associatedtype trait-impl"><a href="#associatedtype.Item-1" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item" class="associatedtype">Item</a> = (<a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'a K</a>, <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;'a mut V</a>)</h4></section></summary><div class='docblock'>The type of the elements being iterated over.</div></details><details class="toggle" open><summary><section id="associatedtype.IntoIter-1" class="associatedtype trait-impl"><a href="#associatedtype.IntoIter-1" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" class="associatedtype">IntoIter</a> = <a class="struct" href="struct.IterMut.html" title="struct hashbrown::hash_map::IterMut">IterMut</a>&lt;'a, K, V&gt;</h4></section></summary><div class='docblock'>Which kind of iterator are we turning this into?</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-IntoIterator-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#4693-4721">source</a><a href="#impl-IntoIterator-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A: Allocator&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.into_iter" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#4716-4720">source</a><a href="#method.into_iter" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter" class="fn">into_iter</a>(self) -&gt; <a class="struct" href="struct.IntoIter.html" title="struct hashbrown::hash_map::IntoIter">IntoIter</a>&lt;K, V, A&gt; <a href="#" class="tooltip" data-notable-ty="IntoIter&lt;K, V, A&gt;">ⓘ</a></h4></section></summary><div class="docblock"><p>Creates a consuming iterator, that is, one that moves each key-value
pair out of the map in arbitrary order. The map cannot be used after
calling this.</p>
<h5 id="examples-43"><a class="doc-anchor" href="#examples-43">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>hashbrown::HashMap;
<span class="kw">let </span>map: HashMap&lt;<span class="kw">_</span>, <span class="kw">_</span>&gt; = [(<span class="string">"a"</span>, <span class="number">1</span>), (<span class="string">"b"</span>, <span class="number">2</span>), (<span class="string">"c"</span>, <span class="number">3</span>)].into();
<span class="comment">// Not possible with .iter()
</span><span class="kw">let </span><span class="kw-2">mut </span>vec: Vec&lt;(<span class="kw-2">&amp;</span>str, i32)&gt; = map.into_iter().collect();
<span class="comment">// The `IntoIter` iterator produces items in arbitrary order, so
// the items must be sorted to test them against a sorted array.
</span>vec.sort_unstable();
<span class="macro">assert_eq!</span>(vec, [(<span class="string">"a"</span>, <span class="number">1</span>), (<span class="string">"b"</span>, <span class="number">2</span>), (<span class="string">"c"</span>, <span class="number">3</span>)]);</code></pre></div>
</div></details><details class="toggle" open><summary><section id="associatedtype.Item" class="associatedtype trait-impl"><a href="#associatedtype.Item" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item" class="associatedtype">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html">(K, V)</a></h4></section></summary><div class='docblock'>The type of the elements being iterated over.</div></details><details class="toggle" open><summary><section id="associatedtype.IntoIter" class="associatedtype trait-impl"><a href="#associatedtype.IntoIter" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" class="associatedtype">IntoIter</a> = <a class="struct" href="struct.IntoIter.html" title="struct hashbrown::hash_map::IntoIter">IntoIter</a>&lt;K, V, A&gt;</h4></section></summary><div class='docblock'>Which kind of iterator are we turning this into?</div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-PartialEq-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2169-2184">source</a><a href="#impl-PartialEq-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a>,
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.BuildHasher.html" title="trait core::hash::BuildHasher">BuildHasher</a>,
A: Allocator,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.eq" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2176-2183">source</a><a href="#method.eq" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.PartialEq.html#tymethod.eq" class="fn">eq</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Self</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used
by <code>==</code>.</div></details><details class="toggle method-toggle" open><summary><section id="method.ne" class="method trait-impl"><span class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span> · <a class="src" href="https://doc.rust-lang.org/1.80.0/src/core/cmp.rs.html#263">source</a></span><a href="#method.ne" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.PartialEq.html#method.ne" class="fn">ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;Rhs</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'>This method tests for <code>!=</code>. The default implementation is almost always
sufficient, and should not be overridden without very good reason.</div></details></div></details><section id="impl-Eq-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a class="src rightside" href="../../src/hashbrown/map.rs.html#2186-2193">source</a><a href="#impl-Eq-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>,
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/hash/trait.BuildHasher.html" title="trait core::hash::BuildHasher">BuildHasher</a>,
A: Allocator,</div></h3></section></div><h2 id="synthetic-implementations" class="section-header">Auto Trait Implementations<a href="#synthetic-implementations" class="anchor">§</a></h2><div id="synthetic-implementations-list"><section id="impl-Freeze-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a href="#impl-Freeze-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Freeze.html" title="trait core::marker::Freeze">Freeze</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Freeze.html" title="trait core::marker::Freeze">Freeze</a>,
A: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Freeze.html" title="trait core::marker::Freeze">Freeze</a>,</div></h3></section><section id="impl-RefUnwindSafe-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a href="#impl-RefUnwindSafe-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a>,
A: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a>,
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a>,</div></h3></section><section id="impl-Send-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a href="#impl-Send-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,
A: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,</div></h3></section><section id="impl-Sync-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a href="#impl-Sync-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>,
A: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>,
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>,</div></h3></section><section id="impl-Unpin-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a href="#impl-Unpin-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a>,
A: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a>,
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a>,</div></h3></section><section id="impl-UnwindSafe-for-HashMap%3CK,+V,+S,+A%3E" class="impl"><a href="#impl-UnwindSafe-for-HashMap%3CK,+V,+S,+A%3E" class="anchor">§</a><h3 class="code-header">impl&lt;K, V, S, A&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a> for <a class="struct" href="struct.HashMap.html" title="struct hashbrown::hash_map::HashMap">HashMap</a>&lt;K, V, S, A&gt;<div class="where">where
S: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a>,
A: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a>,
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a>,
V: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a>,</div></h3></section></div><h2 id="blanket-implementations" class="section-header">Blanket Implementations<a href="#blanket-implementations" class="anchor">§</a></h2><div id="blanket-implementations-list"><details class="toggle implementors-toggle"><summary><section id="impl-Any-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/any.rs.html#140">source</a><a href="#impl-Any-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T<div class="where">where
T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.type_id" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/any.rs.html#141">source</a><a href="#method.type_id" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/any/trait.Any.html#tymethod.type_id" class="fn">type_id</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/1.80.0/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4></section></summary><div class='docblock'>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/1.80.0/core/any/trait.Any.html#tymethod.type_id">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Borrow%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/borrow.rs.html#208">source</a><a href="#impl-Borrow%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;T&gt; for T<div class="where">where
T: ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.borrow" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/borrow.rs.html#210">source</a><a href="#method.borrow" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/borrow/trait.Borrow.html#tymethod.borrow" class="fn">borrow</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.80.0/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-BorrowMut%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/borrow.rs.html#216">source</a><a href="#impl-BorrowMut%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a>&lt;T&gt; for T<div class="where">where
T: ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.borrow_mut" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/borrow.rs.html#217">source</a><a href="#method.borrow_mut" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fn">borrow_mut</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut T</a></h4></section></summary><div class='docblock'>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.80.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Equivalent%3CK%3E-for-Q" class="impl"><a class="src rightside" href="../../src/hashbrown/lib.rs.html#166-174">source</a><a href="#impl-Equivalent%3CK%3E-for-Q" class="anchor">§</a><h3 class="code-header">impl&lt;Q, K&gt; <a class="trait" href="../trait.Equivalent.html" title="trait hashbrown::Equivalent">Equivalent</a>&lt;K&gt; for Q<div class="where">where
Q: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,
K: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;Q&gt; + ?<a class="trait" href="https://doc.rust-lang.org/1.80.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.equivalent" class="method trait-impl"><a class="src rightside" href="../../src/hashbrown/lib.rs.html#171-173">source</a><a href="#method.equivalent" class="anchor">§</a><h4 class="code-header">fn <a href="../trait.Equivalent.html#tymethod.equivalent" class="fn">equivalent</a>(&amp;self, key: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;K</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.bool.html">bool</a></h4></section></summary><div class='docblock'>Checks if this value is equivalent to the given key. <a href="../trait.Equivalent.html#tymethod.equivalent">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-From%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/convert/mod.rs.html#765">source</a><a href="#impl-From%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for T</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.from-1" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/convert/mod.rs.html#768">source</a><a href="#method.from-1" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.From.html#tymethod.from" class="fn">from</a>(t: T) -&gt; T</h4></section></summary><div class="docblock"><p>Returns the argument unchanged.</p>
</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Into%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/convert/mod.rs.html#748-750">source</a><a href="#impl-Into%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;U&gt; for T<div class="where">where
U: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/convert/mod.rs.html#758">source</a><a href="#method.into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.Into.html#tymethod.into" class="fn">into</a>(self) -&gt; U</h4></section></summary><div class="docblock"><p>Calls <code>U::from(self)</code>.</p>
<p>That is, this conversion is whatever the implementation of
<code><a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for U</code> chooses to do.</p>
</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-ToOwned-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/alloc/borrow.rs.html#83-85">source</a><a href="#impl-ToOwned-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T<div class="where">where
T: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Owned" class="associatedtype trait-impl"><a href="#associatedtype.Owned" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/alloc/borrow/trait.ToOwned.html#associatedtype.Owned" class="associatedtype">Owned</a> = T</h4></section></summary><div class='docblock'>The resulting type after obtaining ownership.</div></details><details class="toggle method-toggle" open><summary><section id="method.to_owned" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/alloc/borrow.rs.html#88">source</a><a href="#method.to_owned" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned" class="fn">to_owned</a>(&amp;self) -&gt; T</h4></section></summary><div class='docblock'>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/1.80.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.clone_into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/alloc/borrow.rs.html#92">source</a><a href="#method.clone_into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/alloc/borrow/trait.ToOwned.html#method.clone_into" class="fn">clone_into</a>(&amp;self, target: <a class="primitive" href="https://doc.rust-lang.org/1.80.0/core/primitive.reference.html">&amp;mut T</a>)</h4></section></summary><div class='docblock'>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/1.80.0/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-TryFrom%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/convert/mod.rs.html#805-807">source</a><a href="#impl-TryFrom%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt; for T<div class="where">where
U: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Error" class="associatedtype trait-impl"><a href="#associatedtype.Error" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4></section></summary><div class='docblock'>The type returned in the event of a conversion error.</div></details><details class="toggle method-toggle" open><summary><section id="method.try_from" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/convert/mod.rs.html#812">source</a><a href="#method.try_from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html#tymethod.try_from" class="fn">try_from</a>(value: U) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;T, &lt;T as <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></section></summary><div class='docblock'>Performs the conversion.</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-TryInto%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/convert/mod.rs.html#790-792">source</a><a href="#impl-TryInto%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a>&lt;U&gt; for T<div class="where">where
U: <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Error-1" class="associatedtype trait-impl"><a href="#associatedtype.Error-1" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryInto.html#associatedtype.Error" class="associatedtype">Error</a> = &lt;U as <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4></section></summary><div class='docblock'>The type returned in the event of a conversion error.</div></details><details class="toggle method-toggle" open><summary><section id="method.try_into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.80.0/src/core/convert/mod.rs.html#797">source</a><a href="#method.try_into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryInto.html#tymethod.try_into" class="fn">try_into</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.80.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;U, &lt;U as <a class="trait" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/1.80.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></section></summary><div class='docblock'>Performs the conversion.</div></details></div></details></div><script type="text/json" id="notable-traits-data">{"Drain<'_, K, V, A>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.Drain.html\" title=\"struct hashbrown::hash_map::Drain\">Drain</a>&lt;'a, K, V, A&gt;</code></h3><pre><code><div class=\"where\">impl&lt;'a, K, V, A: Allocator&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.Drain.html\" title=\"struct hashbrown::hash_map::Drain\">Drain</a>&lt;'a, K, V, A&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html\">(K, V)</a>;</div>","ExtractIf<'_, K, V, F, A>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.ExtractIf.html\" title=\"struct hashbrown::hash_map::ExtractIf\">ExtractIf</a>&lt;'_, K, V, F, A&gt;</code></h3><pre><code><div class=\"where\">impl&lt;K, V, F, A&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.ExtractIf.html\" title=\"struct hashbrown::hash_map::ExtractIf\">ExtractIf</a>&lt;'_, K, V, F, A&gt;<div class=\"where\">where\n F: <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/ops/function/trait.FnMut.html\" title=\"trait core::ops::function::FnMut\">FnMut</a>(<a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;mut V</a>) -&gt; <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.bool.html\">bool</a>,\n A: Allocator,</div></div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html\">(K, V)</a>;</div>","IntoIter<K, V, A>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.IntoIter.html\" title=\"struct hashbrown::hash_map::IntoIter\">IntoIter</a>&lt;K, V, A&gt;</code></h3><pre><code><div class=\"where\">impl&lt;K, V, A: Allocator&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.IntoIter.html\" title=\"struct hashbrown::hash_map::IntoIter\">IntoIter</a>&lt;K, V, A&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.tuple.html\">(K, V)</a>;</div>","IntoKeys<K, V, A>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.IntoKeys.html\" title=\"struct hashbrown::hash_map::IntoKeys\">IntoKeys</a>&lt;K, V, A&gt;</code></h3><pre><code><div class=\"where\">impl&lt;K, V, A: Allocator&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.IntoKeys.html\" title=\"struct hashbrown::hash_map::IntoKeys\">IntoKeys</a>&lt;K, V, A&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = K;</div>","IntoValues<K, V, A>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.IntoValues.html\" title=\"struct hashbrown::hash_map::IntoValues\">IntoValues</a>&lt;K, V, A&gt;</code></h3><pre><code><div class=\"where\">impl&lt;K, V, A: Allocator&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.IntoValues.html\" title=\"struct hashbrown::hash_map::IntoValues\">IntoValues</a>&lt;K, V, A&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = V;</div>","Iter<'_, K, V>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.Iter.html\" title=\"struct hashbrown::hash_map::Iter\">Iter</a>&lt;'a, K, V&gt;</code></h3><pre><code><div class=\"where\">impl&lt;'a, K, V&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.Iter.html\" title=\"struct hashbrown::hash_map::Iter\">Iter</a>&lt;'a, K, V&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = (<a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a V</a>);</div>","Iter<'a, K, V>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.Iter.html\" title=\"struct hashbrown::hash_map::Iter\">Iter</a>&lt;'a, K, V&gt;</code></h3><pre><code><div class=\"where\">impl&lt;'a, K, V&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.Iter.html\" title=\"struct hashbrown::hash_map::Iter\">Iter</a>&lt;'a, K, V&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = (<a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a V</a>);</div>","IterMut<'_, K, V>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.IterMut.html\" title=\"struct hashbrown::hash_map::IterMut\">IterMut</a>&lt;'a, K, V&gt;</code></h3><pre><code><div class=\"where\">impl&lt;'a, K, V&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.IterMut.html\" title=\"struct hashbrown::hash_map::IterMut\">IterMut</a>&lt;'a, K, V&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = (<a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a mut V</a>);</div>","IterMut<'a, K, V>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.IterMut.html\" title=\"struct hashbrown::hash_map::IterMut\">IterMut</a>&lt;'a, K, V&gt;</code></h3><pre><code><div class=\"where\">impl&lt;'a, K, V&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.IterMut.html\" title=\"struct hashbrown::hash_map::IterMut\">IterMut</a>&lt;'a, K, V&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = (<a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a K</a>, <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a mut V</a>);</div>","Keys<'_, K, V>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.Keys.html\" title=\"struct hashbrown::hash_map::Keys\">Keys</a>&lt;'a, K, V&gt;</code></h3><pre><code><div class=\"where\">impl&lt;'a, K, V&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.Keys.html\" title=\"struct hashbrown::hash_map::Keys\">Keys</a>&lt;'a, K, V&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a K</a>;</div>","Values<'_, K, V>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.Values.html\" title=\"struct hashbrown::hash_map::Values\">Values</a>&lt;'a, K, V&gt;</code></h3><pre><code><div class=\"where\">impl&lt;'a, K, V&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.Values.html\" title=\"struct hashbrown::hash_map::Values\">Values</a>&lt;'a, K, V&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a V</a>;</div>","ValuesMut<'_, K, V>":"<h3>Notable traits for <code><a class=\"struct\" href=\"struct.ValuesMut.html\" title=\"struct hashbrown::hash_map::ValuesMut\">ValuesMut</a>&lt;'a, K, V&gt;</code></h3><pre><code><div class=\"where\">impl&lt;'a, K, V&gt; <a class=\"trait\" href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html\" title=\"trait core::iter::traits::iterator::Iterator\">Iterator</a> for <a class=\"struct\" href=\"struct.ValuesMut.html\" title=\"struct hashbrown::hash_map::ValuesMut\">ValuesMut</a>&lt;'a, K, V&gt;</div><div class=\"where\"> type <a href=\"https://doc.rust-lang.org/1.80.0/core/iter/traits/iterator/trait.Iterator.html#associatedtype.Item\" class=\"associatedtype\">Item</a> = <a class=\"primitive\" href=\"https://doc.rust-lang.org/1.80.0/core/primitive.reference.html\">&amp;'a mut V</a>;</div>"}</script></section></div></main></body></html>
Reference in a new issue View git blame Copy permalink