Mercator/mercator_service
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
527969729d50e57b483610ffacaa016c42441eac
mercator_service/nom/lib/std/collections/struct.VecDeque.html

732 lines
176 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="API documentation for the Rust `VecDeque` struct in crate `nom`."><meta name="keywords" content="rust, rustlang, rust-lang, VecDeque"><title>nom::lib::std::collections::VecDeque - Rust</title><link rel="stylesheet" type="text/css" href="../../../../normalize.css"><link rel="stylesheet" type="text/css" href="../../../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../../../dark.css"><link rel="stylesheet" type="text/css" href="../../../../light.css" id="themeStyle"><script src="../../../../storage.js"></script><noscript><link rel="stylesheet" href="../../../../noscript.css"></noscript><link rel="shortcut icon" href="../../../../favicon.ico"><style type="text/css">#crate-search{background-image:url("../../../../down-arrow.svg");}</style></head><body class="rustdoc struct"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">&#9776;</div><a href='../../../../nom/index.html'><div class='logo-container'><img src='../../../../rust-logo.png' alt='logo'></div></a><p class='location'>Struct VecDeque</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.append">append</a><a href="#method.as_mut_slices">as_mut_slices</a><a href="#method.as_slices">as_slices</a><a href="#method.back">back</a><a href="#method.back_mut">back_mut</a><a href="#method.capacity">capacity</a><a href="#method.clear">clear</a><a href="#method.contains">contains</a><a href="#method.drain">drain</a><a href="#method.front">front</a><a href="#method.front_mut">front_mut</a><a href="#method.get">get</a><a href="#method.get_mut">get_mut</a><a href="#method.insert">insert</a><a href="#method.is_empty">is_empty</a><a href="#method.iter">iter</a><a href="#method.iter_mut">iter_mut</a><a href="#method.len">len</a><a href="#method.new">new</a><a href="#method.pop_back">pop_back</a><a href="#method.pop_front">pop_front</a><a href="#method.push_back">push_back</a><a href="#method.push_front">push_front</a><a href="#method.remove">remove</a><a href="#method.reserve">reserve</a><a href="#method.reserve_exact">reserve_exact</a><a href="#method.resize">resize</a><a href="#method.resize_with">resize_with</a><a href="#method.retain">retain</a><a href="#method.rotate_left">rotate_left</a><a href="#method.rotate_right">rotate_right</a><a href="#method.shrink_to">shrink_to</a><a href="#method.shrink_to_fit">shrink_to_fit</a><a href="#method.split_off">split_off</a><a href="#method.swap">swap</a><a href="#method.swap_remove_back">swap_remove_back</a><a href="#method.swap_remove_front">swap_remove_front</a><a href="#method.truncate">truncate</a><a href="#method.try_reserve">try_reserve</a><a href="#method.try_reserve_exact">try_reserve_exact</a><a href="#method.with_capacity">with_capacity</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Clone">Clone</a><a href="#impl-Debug">Debug</a><a href="#impl-Default">Default</a><a href="#impl-Drop">Drop</a><a href="#impl-Eq">Eq</a><a href="#impl-Extend%3C%26%27a%20T%3E">Extend&lt;&amp;&#39;a T&gt;</a><a href="#impl-Extend%3CA%3E">Extend&lt;A&gt;</a><a href="#impl-From%3CVec%3CT%3E%3E">From&lt;Vec&lt;T&gt;&gt;</a><a href="#impl-From%3CVecDeque%3CT%3E%3E">From&lt;VecDeque&lt;T&gt;&gt;</a><a href="#impl-FromIterator%3CA%3E">FromIterator&lt;A&gt;</a><a href="#impl-Hash">Hash</a><a href="#impl-Index%3Cusize%3E">Index&lt;usize&gt;</a><a href="#impl-IndexMut%3Cusize%3E">IndexMut&lt;usize&gt;</a><a href="#impl-IntoIterator">IntoIterator</a><a href="#impl-Ord">Ord</a><a href="#impl-PartialEq%3C%26%27_%20%5BB%3B%20N%5D%3E">PartialEq&lt;&amp;&#39;_ [B; N]&gt;</a><a href="#impl-PartialEq%3C%26%27_%20%5BB%5D%3E">PartialEq&lt;&amp;&#39;_ [B]&gt;</a><a href="#impl-PartialEq%3C%26%27_%20mut%20%5BB%3B%20N%5D%3E">PartialEq&lt;&amp;&#39;_ mut [B; N]&gt;</a><a href="#impl-PartialEq%3C%26%27_%20mut%20%5BB%5D%3E">PartialEq&lt;&amp;&#39;_ mut [B]&gt;</a><a href="#impl-PartialEq%3C%5BB%3B%20N%5D%3E">PartialEq&lt;[B; N]&gt;</a><a href="#impl-PartialEq%3CVec%3CB%3E%3E">PartialEq&lt;Vec&lt;B&gt;&gt;</a><a href="#impl-PartialEq%3CVecDeque%3CA%3E%3E">PartialEq&lt;VecDeque&lt;A&gt;&gt;</a><a href="#impl-PartialOrd%3CVecDeque%3CA%3E%3E">PartialOrd&lt;VecDeque&lt;A&gt;&gt;</a></div><a class="sidebar-title" href="#synthetic-implementations">Auto Trait Implementations</a><div class="sidebar-links"><a href="#impl-RefUnwindSafe">RefUnwindSafe</a><a href="#impl-Send">Send</a><a href="#impl-Sync">Sync</a><a href="#impl-Unpin">Unpin</a><a href="#impl-UnwindSafe">UnwindSafe</a></div><a class="sidebar-title" href="#blanket-implementations">Blanket Implementations</a><div class="sidebar-links"><a href="#impl-Any">Any</a><a href="#impl-Borrow%3CT%3E">Borrow&lt;T&gt;</a><a href="#impl-BorrowMut%3CT%3E">BorrowMut&lt;T&gt;</a><a href="#impl-From%3CT%3E">From&lt;T&gt;</a><a href="#impl-Into%3CU%3E">Into&lt;U&gt;</a><a href="#impl-IntoIterator">IntoIterator</a><a href="#impl-ToOwned">ToOwned</a><a href="#impl-TryFrom%3CU%3E">TryFrom&lt;U&gt;</a><a href="#impl-TryInto%3CU%3E">TryInto&lt;U&gt;</a></div></div><p class='location'><a href='../../../index.html'>nom</a>::<wbr><a href='../../index.html'>lib</a>::<wbr><a href='../index.html'>std</a>::<wbr><a href='index.html'>collections</a></p><script>window.sidebarCurrent = {name: 'VecDeque', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!"><img src="../../../../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../../../../theme.js"></script><nav class="sub"><form class="search-form"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" disabled autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><a id="settings-menu" href="../../../../settings.html"><img src="../../../../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class='fqn'><span class='out-of-band'><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><span id='render-detail'><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class='inner'>&#x2212;</span>]</a></span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#54-63' title='goto source code'>[src]</a></span><span class='in-band'>Struct <a href='../../../index.html'>nom</a>::<wbr><a href='../../index.html'>lib</a>::<wbr><a href='../index.html'>std</a>::<wbr><a href='index.html'>collections</a>::<wbr><a class="struct" href=''>VecDeque</a></span></h1><div class="docblock type-decl hidden-by-usual-hider"><pre class='rust struct'>pub struct VecDeque&lt;T&gt; { /* fields omitted */ }</pre></div><div class='docblock'><p>A double-ended queue implemented with a growable ring buffer.</p>
<p>The &quot;default&quot; usage of this type as a queue is to use <a href="#method.push_back"><code>push_back</code></a> to add to
the queue, and <a href="#method.pop_front"><code>pop_front</code></a> to remove from the queue. <a href="#method.extend"><code>extend</code></a> and <a href="#method.append"><code>append</code></a>
push onto the back in this manner, and iterating over <code>VecDeque</code> goes front
to back.</p>
</div><h2 id='methods' class='small-section-header'>Methods<a href='#methods' class='anchor'></a></h2><h3 id='impl' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a href='#impl' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#458-2153' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.new' class="method"><code id='new.v'>pub fn <a href='#method.new' class='fnname'>new</a>() -&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#469-471' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates an empty <code>VecDeque</code>.</p>
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="ident">vector</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();</pre></div>
</div><h4 id='method.with_capacity' class="method"><code id='with_capacity.v'>pub fn <a href='#method.with_capacity' class='fnname'>with_capacity</a>(capacity: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#483-489' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates an empty <code>VecDeque</code> with space for at least <code>capacity</code> elements.</p>
<h1 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="ident">vector</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">with_capacity</span>(<span class="number">10</span>);</pre></div>
</div><h4 id='method.get' class="method"><code id='get.v'>pub fn <a href='#method.get' class='fnname'>get</a>(&amp;self, index: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#507-514' title='goto source code'>[src]</a></h4><div class='docblock'><p>Retrieves an element in the <code>VecDeque</code> by index.</p>
<p>Element at index 0 is the front of the queue.</p>
<h1 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">4</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">5</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">get</span>(<span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">4</span>));</pre></div>
</div><h4 id='method.get_mut' class="method"><code id='get_mut.v'>pub fn <a href='#method.get_mut' class='fnname'>get_mut</a>(&amp;mut self, index: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#536-543' title='goto source code'>[src]</a></h4><div class='docblock'><p>Retrieves an element in the <code>VecDeque</code> mutably by index.</p>
<p>Element at index 0 is the front of the queue.</p>
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">4</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">5</span>);
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">elem</span>) <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">get_mut</span>(<span class="number">1</span>) {
<span class="kw-2">*</span><span class="ident">elem</span> <span class="op">=</span> <span class="number">7</span>;
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>[<span class="number">1</span>], <span class="number">7</span>);</pre></div>
</div><h4 id='method.swap' class="method"><code id='swap.v'>pub fn <a href='#method.swap' class='fnname'>swap</a>(&amp;mut self, i: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, j: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#569-575' title='goto source code'>[src]</a></h4><div class='docblock'><p>Swaps elements at indices <code>i</code> and <code>j</code>.</p>
<p><code>i</code> and <code>j</code> may be equal.</p>
<p>Element at index 0 is the front of the queue.</p>
<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
<p>Panics if either index is out of bounds.</p>
<h1 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">4</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">5</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>]);
<span class="ident">buf</span>.<span class="ident">swap</span>(<span class="number">0</span>, <span class="number">2</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">4</span>, <span class="number">3</span>]);</pre></div>
</div><h4 id='method.capacity' class="method"><code id='capacity.v'>pub fn <a href='#method.capacity' class='fnname'>capacity</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#590-592' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the number of elements the <code>VecDeque</code> can hold without
reallocating.</p>
<h1 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="ident">buf</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="ident">i32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">with_capacity</span>(<span class="number">10</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">capacity</span>() <span class="op">&gt;</span><span class="op">=</span> <span class="number">10</span>);</pre></div>
</div><h4 id='method.reserve_exact' class="method"><code id='reserve_exact.v'>pub fn <a href='#method.reserve_exact' class='fnname'>reserve_exact</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#617-619' title='goto source code'>[src]</a></h4><div class='docblock'><p>Reserves the minimum capacity for exactly <code>additional</code> more elements to be inserted in the
given <code>VecDeque</code>. Does nothing if the capacity is already sufficient.</p>
<p>Note that the allocator may give the collection more space than it requests. Therefore
capacity can not be relied upon to be precisely minimal. Prefer <a href="#method.reserve"><code>reserve</code></a> if future
insertions are expected.</p>
<h1 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h1>
<p>Panics if the new capacity overflows <code>usize</code>.</p>
<h1 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="ident">i32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>].<span class="ident">into_iter</span>().<span class="ident">collect</span>();
<span class="ident">buf</span>.<span class="ident">reserve_exact</span>(<span class="number">10</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">capacity</span>() <span class="op">&gt;</span><span class="op">=</span> <span class="number">11</span>);</pre></div>
</div><h4 id='method.reserve' class="method"><code id='reserve.v'>pub fn <a href='#method.reserve' class='fnname'>reserve</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#638-652' title='goto source code'>[src]</a></h4><div class='docblock'><p>Reserves capacity for at least <code>additional</code> more elements to be inserted in the given
<code>VecDeque</code>. The collection may reserve more space to avoid frequent reallocations.</p>
<h1 id="panics-2" class="section-header"><a href="#panics-2">Panics</a></h1>
<p>Panics if the new capacity overflows <code>usize</code>.</p>
<h1 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="ident">i32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>].<span class="ident">into_iter</span>().<span class="ident">collect</span>();
<span class="ident">buf</span>.<span class="ident">reserve</span>(<span class="number">10</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">capacity</span>() <span class="op">&gt;</span><span class="op">=</span> <span class="number">11</span>);</pre></div>
</div><h4 id='method.try_reserve_exact' class="method"><code id='try_reserve_exact.v'>pub fn <a href='#method.try_reserve_exact' class='fnname'>try_reserve_exact</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;mut self, <br>&nbsp;&nbsp;&nbsp;&nbsp;additional: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a><br>) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Result.html" title="enum nom::lib::std::prelude::v1::v1::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="enum" href="../../../../nom/lib/std/collections/enum.TryReserveError.html" title="enum nom::lib::std::collections::TryReserveError">TryReserveError</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#691-693' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab unstable'><details><summary><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>try_reserve</code>)</summary><p>new API</p>
</details></div></div><div class='docblock'><p>Tries to reserves the minimum capacity for exactly <code>additional</code> more elements to
be inserted in the given <code>VecDeque&lt;T&gt;</code>. After calling <code>reserve_exact</code>,
capacity will be greater than or equal to <code>self.len() + additional</code>.
Does nothing if the capacity is already sufficient.</p>
<p>Note that the allocator may give the collection more space than it
requests. Therefore, capacity can not be relied upon to be precisely
minimal. Prefer <code>reserve</code> if future insertions are expected.</p>
<h1 id="errors" class="section-header"><a href="#errors">Errors</a></h1>
<p>If the capacity overflows, or the allocator reports a failure, then an error
is returned.</p>
<h1 id="examples-8" class="section-header"><a href="#examples-8">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">try_reserve</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">TryReserveError</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">fn</span> <span class="ident">process_data</span>(<span class="ident">data</span>: <span class="kw-2">&amp;</span>[<span class="ident">u32</span>]) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Result</span><span class="op">&lt;</span><span class="ident">VecDeque</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span>, <span class="ident">TryReserveError</span><span class="op">&gt;</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">output</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="comment">// Pre-reserve the memory, exiting if we can&#39;t</span>
<span class="ident">output</span>.<span class="ident">try_reserve_exact</span>(<span class="ident">data</span>.<span class="ident">len</span>())<span class="question-mark">?</span>;
<span class="comment">// Now we know this can&#39;t OOM in the middle of our complex work</span>
<span class="ident">output</span>.<span class="ident">extend</span>(<span class="ident">data</span>.<span class="ident">iter</span>().<span class="ident">map</span>(<span class="op">|</span><span class="kw-2">&amp;</span><span class="ident">val</span><span class="op">|</span> {
<span class="ident">val</span> <span class="op">*</span> <span class="number">2</span> <span class="op">+</span> <span class="number">5</span> <span class="comment">// very complicated</span>
}));
<span class="prelude-val">Ok</span>(<span class="ident">output</span>)
}</pre></div>
</div><h4 id='method.try_reserve' class="method"><code id='try_reserve.v'>pub fn <a href='#method.try_reserve' class='fnname'>try_reserve</a>(&amp;mut self, additional: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Result.html" title="enum nom::lib::std::prelude::v1::v1::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="enum" href="../../../../nom/lib/std/collections/enum.TryReserveError.html" title="enum nom::lib::std::collections::TryReserveError">TryReserveError</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#729-744' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab unstable'><details><summary><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>try_reserve</code>)</summary><p>new API</p>
</details></div></div><div class='docblock'><p>Tries to reserve capacity for at least <code>additional</code> more elements to be inserted
in the given <code>VecDeque&lt;T&gt;</code>. The collection may reserve more space to avoid
frequent reallocations. After calling <code>reserve</code>, capacity will be
greater than or equal to <code>self.len() + additional</code>. Does nothing if
capacity is already sufficient.</p>
<h1 id="errors-1" class="section-header"><a href="#errors-1">Errors</a></h1>
<p>If the capacity overflows, or the allocator reports a failure, then an error
is returned.</p>
<h1 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">try_reserve</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">TryReserveError</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">fn</span> <span class="ident">process_data</span>(<span class="ident">data</span>: <span class="kw-2">&amp;</span>[<span class="ident">u32</span>]) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Result</span><span class="op">&lt;</span><span class="ident">VecDeque</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span>, <span class="ident">TryReserveError</span><span class="op">&gt;</span> {
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">output</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="comment">// Pre-reserve the memory, exiting if we can&#39;t</span>
<span class="ident">output</span>.<span class="ident">try_reserve</span>(<span class="ident">data</span>.<span class="ident">len</span>())<span class="question-mark">?</span>;
<span class="comment">// Now we know this can&#39;t OOM in the middle of our complex work</span>
<span class="ident">output</span>.<span class="ident">extend</span>(<span class="ident">data</span>.<span class="ident">iter</span>().<span class="ident">map</span>(<span class="op">|</span><span class="kw-2">&amp;</span><span class="ident">val</span><span class="op">|</span> {
<span class="ident">val</span> <span class="op">*</span> <span class="number">2</span> <span class="op">+</span> <span class="number">5</span> <span class="comment">// very complicated</span>
}));
<span class="prelude-val">Ok</span>(<span class="ident">output</span>)
}</pre></div>
</div><h4 id='method.shrink_to_fit' class="method"><code id='shrink_to_fit.v'>pub fn <a href='#method.shrink_to_fit' class='fnname'>shrink_to_fit</a>(&amp;mut self)</code><span class='since' title='Stable since Rust version 1.5.0'>1.5.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#763-765' title='goto source code'>[src]</a></h4><div class='docblock'><p>Shrinks the capacity of the <code>VecDeque</code> as much as possible.</p>
<p>It will drop down as close as possible to the length but the allocator may still inform the
<code>VecDeque</code> that there is space for a few more elements.</p>
<h1 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">with_capacity</span>(<span class="number">15</span>);
<span class="ident">buf</span>.<span class="ident">extend</span>(<span class="number">0</span>..<span class="number">4</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">capacity</span>(), <span class="number">15</span>);
<span class="ident">buf</span>.<span class="ident">shrink_to_fit</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">capacity</span>() <span class="op">&gt;</span><span class="op">=</span> <span class="number">4</span>);</pre></div>
</div><h4 id='method.shrink_to' class="method"><code id='shrink_to.v'>pub fn <a href='#method.shrink_to' class='fnname'>shrink_to</a>(&amp;mut self, min_capacity: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#790-851' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab unstable'><details><summary><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>shrink_to</code>)</summary><p>new API</p>
</details></div></div><div class='docblock'><p>Shrinks the capacity of the <code>VecDeque</code> with a lower bound.</p>
<p>The capacity will remain at least as large as both the length
and the supplied value.</p>
<p>Panics if the current capacity is smaller than the supplied
minimum capacity.</p>
<h1 id="examples-11" class="section-header"><a href="#examples-11">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">shrink_to</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">with_capacity</span>(<span class="number">15</span>);
<span class="ident">buf</span>.<span class="ident">extend</span>(<span class="number">0</span>..<span class="number">4</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">capacity</span>(), <span class="number">15</span>);
<span class="ident">buf</span>.<span class="ident">shrink_to</span>(<span class="number">6</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">capacity</span>() <span class="op">&gt;</span><span class="op">=</span> <span class="number">6</span>);
<span class="ident">buf</span>.<span class="ident">shrink_to</span>(<span class="number">0</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">capacity</span>() <span class="op">&gt;</span><span class="op">=</span> <span class="number">4</span>);</pre></div>
</div><h4 id='method.truncate' class="method"><code id='truncate.v'>pub fn <a href='#method.truncate' class='fnname'>truncate</a>(&amp;mut self, len: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><span class='since' title='Stable since Rust version 1.16.0'>1.16.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#873-915' title='goto source code'>[src]</a></h4><div class='docblock'><p>Shortens the <code>VecDeque</code>, keeping the first <code>len</code> elements and dropping
the rest.</p>
<p>If <code>len</code> is greater than the <code>VecDeque</code>'s current length, this has no
effect.</p>
<h1 id="examples-12" class="section-header"><a href="#examples-12">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">5</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">10</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">15</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">10</span>, <span class="number">15</span>]);
<span class="ident">buf</span>.<span class="ident">truncate</span>(<span class="number">1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>]);</pre></div>
</div><h4 id='method.iter' class="method"><code id='iter.v'>pub fn <a href='#method.iter' class='fnname'>iter</a>(&amp;self) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.Iter.html" title="struct nom::lib::std::collections::vec_deque::Iter">Iter</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#933-935' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns a front-to-back iterator.</p>
<h1 id="examples-13" class="section-header"><a href="#examples-13">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">5</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">4</span>);
<span class="kw">let</span> <span class="ident">b</span>: <span class="kw-2">&amp;</span>[<span class="kw">_</span>] <span class="op">=</span> <span class="kw-2">&amp;</span>[<span class="kw-2">&amp;</span><span class="number">5</span>, <span class="kw-2">&amp;</span><span class="number">3</span>, <span class="kw-2">&amp;</span><span class="number">4</span>];
<span class="kw">let</span> <span class="ident">c</span>: <span class="ident">Vec</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">i32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">iter</span>().<span class="ident">collect</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">&amp;</span><span class="ident">c</span>[..], <span class="ident">b</span>);</pre></div>
</div><h4 id='method.iter_mut' class="method"><code id='iter_mut.v'>pub fn <a href='#method.iter_mut' class='fnname'>iter_mut</a>(&amp;mut self) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.IterMut.html" title="struct nom::lib::std::collections::vec_deque::IterMut">IterMut</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#955-957' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns a front-to-back iterator that returns mutable references.</p>
<h1 id="examples-14" class="section-header"><a href="#examples-14">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">5</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">4</span>);
<span class="kw">for</span> <span class="ident">num</span> <span class="kw">in</span> <span class="ident">buf</span>.<span class="ident">iter_mut</span>() {
<span class="kw-2">*</span><span class="ident">num</span> <span class="op">=</span> <span class="kw-2">*</span><span class="ident">num</span> <span class="op">-</span> <span class="number">2</span>;
}
<span class="kw">let</span> <span class="ident">b</span>: <span class="kw-2">&amp;</span>[<span class="kw">_</span>] <span class="op">=</span> <span class="kw-2">&amp;</span>[<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="number">3</span>, <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="number">1</span>, <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="number">2</span>];
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">&amp;</span><span class="ident">buf</span>.<span class="ident">iter_mut</span>().<span class="ident">collect</span>::<span class="op">&lt;</span><span class="ident">Vec</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">i32</span><span class="op">&gt;</span><span class="op">&gt;</span>()[..], <span class="ident">b</span>);</pre></div>
</div><h4 id='method.as_slices' class="method"><code id='as_slices.v'>pub fn <a href='#method.as_slices' class='fnname'>as_slices</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[T]</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[T]</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code><span class='since' title='Stable since Rust version 1.5.0'>1.5.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#982-987' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns a pair of slices which contain, in order, the contents of the
<code>VecDeque</code>.</p>
<h1 id="examples-15" class="section-header"><a href="#examples-15">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">vector</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">vector</span>.<span class="ident">push_back</span>(<span class="number">0</span>);
<span class="ident">vector</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">vector</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vector</span>.<span class="ident">as_slices</span>(), (<span class="kw-2">&amp;</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>][..], <span class="kw-2">&amp;</span>[][..]));
<span class="ident">vector</span>.<span class="ident">push_front</span>(<span class="number">10</span>);
<span class="ident">vector</span>.<span class="ident">push_front</span>(<span class="number">9</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vector</span>.<span class="ident">as_slices</span>(), (<span class="kw-2">&amp;</span>[<span class="number">9</span>, <span class="number">10</span>][..], <span class="kw-2">&amp;</span>[<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>][..]));</pre></div>
</div><h4 id='method.as_mut_slices' class="method"><code id='as_mut_slices.v'>pub fn <a href='#method.as_mut_slices' class='fnname'>as_mut_slices</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">(</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;mut [T]</a>, <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;mut [T]</a><a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.tuple.html">)</a></code><span class='since' title='Stable since Rust version 1.5.0'>1.5.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1011-1018' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns a pair of slices which contain, in order, the contents of the
<code>VecDeque</code>.</p>
<h1 id="examples-16" class="section-header"><a href="#examples-16">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">vector</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">vector</span>.<span class="ident">push_back</span>(<span class="number">0</span>);
<span class="ident">vector</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">vector</span>.<span class="ident">push_front</span>(<span class="number">10</span>);
<span class="ident">vector</span>.<span class="ident">push_front</span>(<span class="number">9</span>);
<span class="ident">vector</span>.<span class="ident">as_mut_slices</span>().<span class="number">0</span>[<span class="number">0</span>] <span class="op">=</span> <span class="number">42</span>;
<span class="ident">vector</span>.<span class="ident">as_mut_slices</span>().<span class="number">1</span>[<span class="number">0</span>] <span class="op">=</span> <span class="number">24</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vector</span>.<span class="ident">as_slices</span>(), (<span class="kw-2">&amp;</span>[<span class="number">42</span>, <span class="number">10</span>][..], <span class="kw-2">&amp;</span>[<span class="number">24</span>, <span class="number">1</span>][..]));</pre></div>
</div><h4 id='method.len' class="method"><code id='len.v'>pub fn <a href='#method.len' class='fnname'>len</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1033-1035' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the number of elements in the <code>VecDeque</code>.</p>
<h1 id="examples-17" class="section-header"><a href="#examples-17">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">v</span>.<span class="ident">len</span>(), <span class="number">0</span>);
<span class="ident">v</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">v</span>.<span class="ident">len</span>(), <span class="number">1</span>);</pre></div>
</div><h4 id='method.is_empty' class="method"><code id='is_empty.v'>pub fn <a href='#method.is_empty' class='fnname'>is_empty</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1050-1052' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <code>true</code> if the <code>VecDeque</code> is empty.</p>
<h1 id="examples-18" class="section-header"><a href="#examples-18">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">v</span>.<span class="ident">is_empty</span>());
<span class="ident">v</span>.<span class="ident">push_front</span>(<span class="number">1</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">v</span>.<span class="ident">is_empty</span>());</pre></div>
</div><h4 id='method.drain' class="method"><code id='drain.v'>pub fn <a href='#method.drain' class='fnname'>drain</a>&lt;R&gt;(&amp;mut self, range: R) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.Drain.html" title="struct nom::lib::std::collections::vec_deque::Drain">Drain</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;R: <a class="trait" href="../../../../nom/lib/std/ops/trait.RangeBounds.html" title="trait nom::lib::std::ops::RangeBounds">RangeBounds</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>&gt;,&nbsp;</span></code><span class='since' title='Stable since Rust version 1.6.0'>1.6.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1085-1150' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates a draining iterator that removes the specified range in the
<code>VecDeque</code> and yields the removed items.</p>
<p>Note 1: The element range is removed even if the iterator is not
consumed until the end.</p>
<p>Note 2: It is unspecified how many elements are removed from the deque,
if the <code>Drain</code> value is not dropped, but the borrow it holds expires
(e.g., due to <code>mem::forget</code>).</p>
<h1 id="panics-3" class="section-header"><a href="#panics-3">Panics</a></h1>
<p>Panics if the starting point is greater than the end point or if
the end point is greater than the length of the vector.</p>
<h1 id="examples-19" class="section-header"><a href="#examples-19">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">v</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>].<span class="ident">into_iter</span>().<span class="ident">collect</span>();
<span class="kw">let</span> <span class="ident">drained</span> <span class="op">=</span> <span class="ident">v</span>.<span class="ident">drain</span>(<span class="number">2</span>..).<span class="ident">collect</span>::<span class="op">&lt;</span><span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span><span class="op">&gt;</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">drained</span>, [<span class="number">3</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">v</span>, [<span class="number">1</span>, <span class="number">2</span>]);
<span class="comment">// A full range clears all contents</span>
<span class="ident">v</span>.<span class="ident">drain</span>(..);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">v</span>.<span class="ident">is_empty</span>());</pre></div>
</div><h4 id='method.clear' class="method"><code id='clear.v'>pub fn <a href='#method.clear' class='fnname'>clear</a>(&amp;mut self)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1166-1168' title='goto source code'>[src]</a></h4><div class='docblock'><p>Clears the <code>VecDeque</code>, removing all values.</p>
<h1 id="examples-20" class="section-header"><a href="#examples-20">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">v</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">v</span>.<span class="ident">clear</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">v</span>.<span class="ident">is_empty</span>());</pre></div>
</div><h4 id='method.contains' class="method"><code id='contains.v'>pub fn <a href='#method.contains' class='fnname'>contains</a>(&amp;self, x: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;T&gt;,&nbsp;</span></code><span class='since' title='Stable since Rust version 1.12.0'>1.12.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1187-1193' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <code>true</code> if the <code>VecDeque</code> contains an element equal to the
given value.</p>
<h1 id="examples-21" class="section-header"><a href="#examples-21">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">vector</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">vector</span>.<span class="ident">push_back</span>(<span class="number">0</span>);
<span class="ident">vector</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vector</span>.<span class="ident">contains</span>(<span class="kw-2">&amp;</span><span class="number">1</span>), <span class="bool-val">true</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vector</span>.<span class="ident">contains</span>(<span class="kw-2">&amp;</span><span class="number">10</span>), <span class="bool-val">false</span>);</pre></div>
</div><h4 id='method.front' class="method"><code id='front.v'>pub fn <a href='#method.front' class='fnname'>front</a>(&amp;self) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1211-1213' title='goto source code'>[src]</a></h4><div class='docblock'><p>Provides a reference to the front element, or <code>None</code> if the <code>VecDeque</code> is
empty.</p>
<h1 id="examples-22" class="section-header"><a href="#examples-22">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">d</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">front</span>(), <span class="prelude-val">None</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">front</span>(), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">1</span>));</pre></div>
</div><h4 id='method.front_mut' class="method"><code id='front_mut.v'>pub fn <a href='#method.front_mut' class='fnname'>front_mut</a>(&amp;mut self) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1235-1237' title='goto source code'>[src]</a></h4><div class='docblock'><p>Provides a mutable reference to the front element, or <code>None</code> if the
<code>VecDeque</code> is empty.</p>
<h1 id="examples-23" class="section-header"><a href="#examples-23">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">d</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">front_mut</span>(), <span class="prelude-val">None</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="kw">match</span> <span class="ident">d</span>.<span class="ident">front_mut</span>() {
<span class="prelude-val">Some</span>(<span class="ident">x</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="kw-2">*</span><span class="ident">x</span> <span class="op">=</span> <span class="number">9</span>,
<span class="prelude-val">None</span> <span class="op">=</span><span class="op">&gt;</span> (),
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">front</span>(), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">9</span>));</pre></div>
</div><h4 id='method.back' class="method"><code id='back.v'>pub fn <a href='#method.back' class='fnname'>back</a>(&amp;self) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1255-1257' title='goto source code'>[src]</a></h4><div class='docblock'><p>Provides a reference to the back element, or <code>None</code> if the <code>VecDeque</code> is
empty.</p>
<h1 id="examples-24" class="section-header"><a href="#examples-24">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">d</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">back</span>(), <span class="prelude-val">None</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">back</span>(), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">2</span>));</pre></div>
</div><h4 id='method.back_mut' class="method"><code id='back_mut.v'>pub fn <a href='#method.back_mut' class='fnname'>back_mut</a>(&amp;mut self) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1279-1282' title='goto source code'>[src]</a></h4><div class='docblock'><p>Provides a mutable reference to the back element, or <code>None</code> if the
<code>VecDeque</code> is empty.</p>
<h1 id="examples-25" class="section-header"><a href="#examples-25">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">d</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">back</span>(), <span class="prelude-val">None</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="kw">match</span> <span class="ident">d</span>.<span class="ident">back_mut</span>() {
<span class="prelude-val">Some</span>(<span class="ident">x</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="kw-2">*</span><span class="ident">x</span> <span class="op">=</span> <span class="number">9</span>,
<span class="prelude-val">None</span> <span class="op">=</span><span class="op">&gt;</span> (),
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">back</span>(), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">9</span>));</pre></div>
</div><h4 id='method.pop_front' class="method"><code id='pop_front.v'>pub fn <a href='#method.pop_front' class='fnname'>pop_front</a>(&amp;mut self) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1301-1309' title='goto source code'>[src]</a></h4><div class='docblock'><p>Removes the first element and returns it, or <code>None</code> if the <code>VecDeque</code> is
empty.</p>
<h1 id="examples-26" class="section-header"><a href="#examples-26">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">d</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">d</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">pop_front</span>(), <span class="prelude-val">Some</span>(<span class="number">1</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">pop_front</span>(), <span class="prelude-val">Some</span>(<span class="number">2</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">pop_front</span>(), <span class="prelude-val">None</span>);</pre></div>
</div><h4 id='method.pop_back' class="method"><code id='pop_back.v'>pub fn <a href='#method.pop_back' class='fnname'>pop_back</a>(&amp;mut self) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1326-1334' title='goto source code'>[src]</a></h4><div class='docblock'><p>Removes the last element from the <code>VecDeque</code> and returns it, or <code>None</code> if
it is empty.</p>
<h1 id="examples-27" class="section-header"><a href="#examples-27">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">pop_back</span>(), <span class="prelude-val">None</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">pop_back</span>(), <span class="prelude-val">Some</span>(<span class="number">3</span>));</pre></div>
</div><h4 id='method.push_front' class="method"><code id='push_front.v'>pub fn <a href='#method.push_front' class='fnname'>push_front</a>(&amp;mut self, value: T)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1349-1357' title='goto source code'>[src]</a></h4><div class='docblock'><p>Prepends an element to the <code>VecDeque</code>.</p>
<h1 id="examples-28" class="section-header"><a href="#examples-28">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">d</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">d</span>.<span class="ident">push_front</span>(<span class="number">1</span>);
<span class="ident">d</span>.<span class="ident">push_front</span>(<span class="number">2</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">d</span>.<span class="ident">front</span>(), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">2</span>));</pre></div>
</div><h4 id='method.push_back' class="method"><code id='push_back.v'>pub fn <a href='#method.push_back' class='fnname'>push_back</a>(&amp;mut self, value: T)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1372-1378' title='goto source code'>[src]</a></h4><div class='docblock'><p>Appends an element to the back of the <code>VecDeque</code>.</p>
<h1 id="examples-29" class="section-header"><a href="#examples-29">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">3</span>, <span class="kw-2">*</span><span class="ident">buf</span>.<span class="ident">back</span>().<span class="ident">unwrap</span>());</pre></div>
</div><h4 id='method.swap_remove_front' class="method"><code id='swap_remove_front.v'>pub fn <a href='#method.swap_remove_front' class='fnname'>swap_remove_front</a>(&amp;mut self, index: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;T&gt;</code><span class='since' title='Stable since Rust version 1.5.0'>1.5.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1410-1418' title='goto source code'>[src]</a></h4><div class='docblock'><p>Removes an element from anywhere in the <code>VecDeque</code> and returns it,
replacing it with the first element.</p>
<p>This does not preserve ordering, but is O(1).</p>
<p>Returns <code>None</code> if <code>index</code> is out of bounds.</p>
<p>Element at index 0 is the front of the queue.</p>
<h1 id="examples-30" class="section-header"><a href="#examples-30">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">swap_remove_front</span>(<span class="number">0</span>), <span class="prelude-val">None</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">swap_remove_front</span>(<span class="number">2</span>), <span class="prelude-val">Some</span>(<span class="number">3</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">2</span>, <span class="number">1</span>]);</pre></div>
</div><h4 id='method.swap_remove_back' class="method"><code id='swap_remove_back.v'>pub fn <a href='#method.swap_remove_back' class='fnname'>swap_remove_back</a>(&amp;mut self, index: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;T&gt;</code><span class='since' title='Stable since Rust version 1.5.0'>1.5.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1445-1453' title='goto source code'>[src]</a></h4><div class='docblock'><p>Removes an element from anywhere in the <code>VecDeque</code> and returns it, replacing it with the
last element.</p>
<p>This does not preserve ordering, but is O(1).</p>
<p>Returns <code>None</code> if <code>index</code> is out of bounds.</p>
<p>Element at index 0 is the front of the queue.</p>
<h1 id="examples-31" class="section-header"><a href="#examples-31">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">swap_remove_back</span>(<span class="number">0</span>), <span class="prelude-val">None</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">swap_remove_back</span>(<span class="number">0</span>), <span class="prelude-val">Some</span>(<span class="number">1</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">3</span>, <span class="number">2</span>]);</pre></div>
</div><h4 id='method.insert' class="method"><code id='insert.v'>pub fn <a href='#method.insert' class='fnname'>insert</a>(&amp;mut self, index: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, value: T)</code><span class='since' title='Stable since Rust version 1.5.0'>1.5.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1479-1675' title='goto source code'>[src]</a></h4><div class='docblock'><p>Inserts an element at <code>index</code> within the <code>VecDeque</code>, shifting all elements with indices
greater than or equal to <code>index</code> towards the back.</p>
<p>Element at index 0 is the front of the queue.</p>
<h1 id="panics-4" class="section-header"><a href="#panics-4">Panics</a></h1>
<p>Panics if <code>index</code> is greater than <code>VecDeque</code>'s length</p>
<h1 id="examples-32" class="section-header"><a href="#examples-32">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">vec_deque</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">vec_deque</span>.<span class="ident">push_back</span>(<span class="string">&#39;a&#39;</span>);
<span class="ident">vec_deque</span>.<span class="ident">push_back</span>(<span class="string">&#39;b&#39;</span>);
<span class="ident">vec_deque</span>.<span class="ident">push_back</span>(<span class="string">&#39;c&#39;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vec_deque</span>, <span class="kw-2">&amp;</span>[<span class="string">&#39;a&#39;</span>, <span class="string">&#39;b&#39;</span>, <span class="string">&#39;c&#39;</span>]);
<span class="ident">vec_deque</span>.<span class="ident">insert</span>(<span class="number">1</span>, <span class="string">&#39;d&#39;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vec_deque</span>, <span class="kw-2">&amp;</span>[<span class="string">&#39;a&#39;</span>, <span class="string">&#39;d&#39;</span>, <span class="string">&#39;b&#39;</span>, <span class="string">&#39;c&#39;</span>]);</pre></div>
</div><h4 id='method.remove' class="method"><code id='remove.v'>pub fn <a href='#method.remove' class='fnname'>remove</a>(&amp;mut self, index: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1699-1853' title='goto source code'>[src]</a></h4><div class='docblock'><p>Removes and returns the element at <code>index</code> from the <code>VecDeque</code>.
Whichever end is closer to the removal point will be moved to make
room, and all the affected elements will be moved to new positions.
Returns <code>None</code> if <code>index</code> is out of bounds.</p>
<p>Element at index 0 is the front of the queue.</p>
<h1 id="examples-33" class="section-header"><a href="#examples-33">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">1</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">2</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>.<span class="ident">remove</span>(<span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">1</span>, <span class="number">3</span>]);</pre></div>
</div><h4 id='method.split_off' class="method"><code id='split_off.v'>pub fn <a href='#method.split_off' class='fnname'>split_off</a>(&amp;mut self, at: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><span class='since' title='Stable since Rust version 1.4.0'>1.4.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1880-1922' title='goto source code'>[src]</a></h4><div class='docblock'><p>Splits the <code>VecDeque</code> into two at the given index.</p>
<p>Returns a newly allocated <code>VecDeque</code>. <code>self</code> contains elements <code>[0, at)</code>,
and the returned <code>VecDeque</code> contains elements <code>[at, len)</code>.</p>
<p>Note that the capacity of <code>self</code> does not change.</p>
<p>Element at index 0 is the front of the queue.</p>
<h1 id="panics-5" class="section-header"><a href="#panics-5">Panics</a></h1>
<p>Panics if <code>at &gt; len</code>.</p>
<h1 id="examples-34" class="section-header"><a href="#examples-34">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>,<span class="number">2</span>,<span class="number">3</span>].<span class="ident">into_iter</span>().<span class="ident">collect</span>();
<span class="kw">let</span> <span class="ident">buf2</span> <span class="op">=</span> <span class="ident">buf</span>.<span class="ident">split_off</span>(<span class="number">1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">1</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf2</span>, [<span class="number">2</span>, <span class="number">3</span>]);</pre></div>
</div><h4 id='method.append' class="method"><code id='append.v'>pub fn <a href='#method.append' class='fnname'>append</a>(&amp;mut self, other: &amp;mut <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;)</code><span class='since' title='Stable since Rust version 1.4.0'>1.4.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1943-1946' title='goto source code'>[src]</a></h4><div class='docblock'><p>Moves all the elements of <code>other</code> into <code>self</code>, leaving <code>other</code> empty.</p>
<h1 id="panics-6" class="section-header"><a href="#panics-6">Panics</a></h1>
<p>Panics if the new number of elements in self overflows a <code>usize</code>.</p>
<h1 id="examples-35" class="section-header"><a href="#examples-35">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">1</span>, <span class="number">2</span>].<span class="ident">into_iter</span>().<span class="ident">collect</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf2</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">3</span>, <span class="number">4</span>].<span class="ident">into_iter</span>().<span class="ident">collect</span>();
<span class="ident">buf</span>.<span class="ident">append</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">buf2</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf2</span>, []);</pre></div>
</div><h4 id='method.retain' class="method"><code id='retain.v'>pub fn <a href='#method.retain' class='fnname'>retain</a>&lt;F&gt;(&amp;mut self, f: F) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnMut.html" title="trait nom::lib::std::prelude::v1::v1::FnMut">FnMut</a>(<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a>,&nbsp;</span></code><span class='since' title='Stable since Rust version 1.4.0'>1.4.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#1979-1995' title='goto source code'>[src]</a></h4><div class='docblock'><p>Retains only the elements specified by the predicate.</p>
<p>In other words, remove all elements <code>e</code> such that <code>f(&amp;e)</code> returns false.
This method operates in place, visiting each element exactly once in the
original order, and preserves the order of the retained elements.</p>
<h1 id="examples-36" class="section-header"><a href="#examples-36">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">extend</span>(<span class="number">1</span>..<span class="number">5</span>);
<span class="ident">buf</span>.<span class="ident">retain</span>(<span class="op">|</span><span class="kw-2">&amp;</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span> <span class="op">%</span> <span class="number">2</span> <span class="op">=</span><span class="op">=</span> <span class="number">0</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">2</span>, <span class="number">4</span>]);</pre></div>
<p>The exact order may be useful for tracking external state, like an index.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">extend</span>(<span class="number">1</span>..<span class="number">6</span>);
<span class="kw">let</span> <span class="ident">keep</span> <span class="op">=</span> [<span class="bool-val">false</span>, <span class="bool-val">true</span>, <span class="bool-val">true</span>, <span class="bool-val">false</span>, <span class="bool-val">true</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">i</span> <span class="op">=</span> <span class="number">0</span>;
<span class="ident">buf</span>.<span class="ident">retain</span>(<span class="op">|</span><span class="kw">_</span><span class="op">|</span> (<span class="ident">keep</span>[<span class="ident">i</span>], <span class="ident">i</span> <span class="op">+</span><span class="op">=</span> <span class="number">1</span>).<span class="number">0</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">2</span>, <span class="number">3</span>, <span class="number">5</span>]);</pre></div>
</div><h4 id='method.resize_with' class="method"><code id='resize_with.v'>pub fn <a href='#method.resize_with' class='fnname'>resize_with</a>(&amp;mut self, new_len: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, generator: impl <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnMut.html" title="trait nom::lib::std::prelude::v1::v1::FnMut">FnMut</a>() -&gt; T)</code><span class='since' title='Stable since Rust version 1.33.0'>1.33.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2036-2044' title='goto source code'>[src]</a></h4><div class='docblock'><p>Modifies the <code>VecDeque</code> in-place so that <code>len()</code> is equal to <code>new_len</code>,
either by removing excess elements from the back or by appending
elements generated by calling <code>generator</code> to the back.</p>
<h1 id="examples-37" class="section-header"><a href="#examples-37">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">5</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">10</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">15</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">10</span>, <span class="number">15</span>]);
<span class="ident">buf</span>.<span class="ident">resize_with</span>(<span class="number">5</span>, <span class="ident">Default</span>::<span class="ident">default</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">10</span>, <span class="number">15</span>, <span class="number">0</span>, <span class="number">0</span>]);
<span class="ident">buf</span>.<span class="ident">resize_with</span>(<span class="number">2</span>, <span class="op">|</span><span class="op">|</span> <span class="macro">unreachable</span><span class="macro">!</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">10</span>]);
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">state</span> <span class="op">=</span> <span class="number">100</span>;
<span class="ident">buf</span>.<span class="ident">resize_with</span>(<span class="number">5</span>, <span class="op">|</span><span class="op">|</span> { <span class="ident">state</span> <span class="op">+</span><span class="op">=</span> <span class="number">1</span>; <span class="ident">state</span> });
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">10</span>, <span class="number">101</span>, <span class="number">102</span>, <span class="number">103</span>]);</pre></div>
</div><h4 id='method.rotate_left' class="method"><code id='rotate_left.v'>pub fn <a href='#method.rotate_left' class='fnname'>rotate_left</a>(&amp;mut self, mid: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><span class='since' title='Stable since Rust version 1.36.0'>1.36.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2079-2087' title='goto source code'>[src]</a></h4><div class='docblock'><p>Rotates the double-ended queue <code>mid</code> places to the left.</p>
<p>Equivalently,</p>
<ul>
<li>Rotates item <code>mid</code> into the first position.</li>
<li>Pops the first <code>mid</code> items and pushes them to the end.</li>
<li>Rotates <code>len() - mid</code> places to the right.</li>
</ul>
<h1 id="panics-7" class="section-header"><a href="#panics-7">Panics</a></h1>
<p>If <code>mid</code> is greater than <code>len()</code>. Note that <code>mid == len()</code>
does <em>not</em> panic and is a no-op rotation.</p>
<h1 id="complexity" class="section-header"><a href="#complexity">Complexity</a></h1>
<p>Takes <code>O(min(mid, len() - mid))</code> time and no extra space.</p>
<h1 id="examples-38" class="section-header"><a href="#examples-38">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span> <span class="op">=</span> (<span class="number">0</span>..<span class="number">10</span>).<span class="ident">collect</span>();
<span class="ident">buf</span>.<span class="ident">rotate_left</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>]);
<span class="kw">for</span> <span class="ident">i</span> <span class="kw">in</span> <span class="number">1</span>..<span class="number">10</span> {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i</span> <span class="op">*</span> <span class="number">3</span> <span class="op">%</span> <span class="number">10</span>, <span class="ident">buf</span>[<span class="number">0</span>]);
<span class="ident">buf</span>.<span class="ident">rotate_left</span>(<span class="number">3</span>);
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>]);</pre></div>
</div><h4 id='method.rotate_right' class="method"><code id='rotate_right.v'>pub fn <a href='#method.rotate_right' class='fnname'>rotate_right</a>(&amp;mut self, k: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>)</code><span class='since' title='Stable since Rust version 1.36.0'>1.36.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2122-2130' title='goto source code'>[src]</a></h4><div class='docblock'><p>Rotates the double-ended queue <code>k</code> places to the right.</p>
<p>Equivalently,</p>
<ul>
<li>Rotates the first item into position <code>k</code>.</li>
<li>Pops the last <code>k</code> items and pushes them to the front.</li>
<li>Rotates <code>len() - k</code> places to the left.</li>
</ul>
<h1 id="panics-8" class="section-header"><a href="#panics-8">Panics</a></h1>
<p>If <code>k</code> is greater than <code>len()</code>. Note that <code>k == len()</code>
does <em>not</em> panic and is a no-op rotation.</p>
<h1 id="complexity-1" class="section-header"><a href="#complexity-1">Complexity</a></h1>
<p>Takes <code>O(min(k, len() - k))</code> time and no extra space.</p>
<h1 id="examples-39" class="section-header"><a href="#examples-39">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span> <span class="op">=</span> (<span class="number">0</span>..<span class="number">10</span>).<span class="ident">collect</span>();
<span class="ident">buf</span>.<span class="ident">rotate_right</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>, <span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>]);
<span class="kw">for</span> <span class="ident">i</span> <span class="kw">in</span> <span class="number">1</span>..<span class="number">10</span> {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0</span>, <span class="ident">buf</span>[<span class="ident">i</span> <span class="op">*</span> <span class="number">3</span> <span class="op">%</span> <span class="number">10</span>]);
<span class="ident">buf</span>.<span class="ident">rotate_right</span>(<span class="number">3</span>);
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">0</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>, <span class="number">5</span>, <span class="number">6</span>, <span class="number">7</span>, <span class="number">8</span>, <span class="number">9</span>]);</pre></div>
</div></div><h3 id='impl-1' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Clone.html" title="trait nom::lib::std::prelude::v1::v1::Clone">Clone</a>,&nbsp;</span></code><a href='#impl-1' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2155-2181' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.resize' class="method"><code id='resize.v'>pub fn <a href='#method.resize' class='fnname'>resize</a>(&amp;mut self, new_len: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, value: T)</code><span class='since' title='Stable since Rust version 1.16.0'>1.16.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2178-2180' title='goto source code'>[src]</a></h4><div class='docblock'><p>Modifies the <code>VecDeque</code> in-place so that <code>len()</code> is equal to new_len,
either by removing excess elements from the back or by appending clones of <code>value</code>
to the back.</p>
<h1 id="examples-40" class="section-header"><a href="#examples-40">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">buf</span> <span class="op">=</span> <span class="ident">VecDeque</span>::<span class="ident">new</span>();
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">5</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">10</span>);
<span class="ident">buf</span>.<span class="ident">push_back</span>(<span class="number">15</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">10</span>, <span class="number">15</span>]);
<span class="ident">buf</span>.<span class="ident">resize</span>(<span class="number">2</span>, <span class="number">0</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">10</span>]);
<span class="ident">buf</span>.<span class="ident">resize</span>(<span class="number">5</span>, <span class="number">20</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">buf</span>, [<span class="number">5</span>, <span class="number">10</span>, <span class="number">20</span>, <span class="number">20</span>, <span class="number">20</span>]);</pre></div>
</div></div><h2 id='implementations' class='small-section-header'>Trait Implementations<a href='#implementations' class='anchor'></a></h2><div id='implementations-list'><h3 id='impl-Clone' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Clone.html" title="trait nom::lib::std::prelude::v1::v1::Clone">Clone</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Clone.html" title="trait nom::lib::std::prelude::v1::v1::Clone">Clone</a>,&nbsp;</span></code><a href='#impl-Clone' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#127-146' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.clone' class="method hidden"><code id='clone.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&amp;self) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#128-130' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Returns a copy of the value. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Clone.html#tymethod.clone">Read more</a></p>
</div><h4 id='method.clone_from' class="method hidden"><code id='clone_from.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&amp;mut self, other: &amp;<a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#132-145' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs copy-assignment from <code>source</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Clone.html#method.clone_from">Read more</a></p>
</div></div><h3 id='impl-Debug' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/fmt/trait.Debug.html" title="trait nom::lib::std::fmt::Debug">Debug</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/fmt/trait.Debug.html" title="trait nom::lib::std::fmt::Debug">Debug</a>,&nbsp;</span></code><a href='#impl-Debug' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2736-2740' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.fmt' class="method hidden"><code id='fmt.v'>fn <a href='../../../../nom/lib/std/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&amp;self, f: &amp;mut <a class="struct" href="../../../../nom/lib/std/fmt/struct.Formatter.html" title="struct nom::lib::std::fmt::Formatter">Formatter</a>) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Result.html" title="enum nom::lib::std::prelude::v1::v1::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.unit.html">()</a>, <a class="struct" href="../../../../nom/lib/std/fmt/struct.Error.html" title="struct nom::lib::std::fmt::Error">Error</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2737-2739' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Formats the value using the given formatter. <a href="../../../../nom/lib/std/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></div><h3 id='impl-Default' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Default.html" title="trait nom::lib::std::prelude::v1::v1::Default">Default</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a href='#impl-Default' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#174-180' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.default' class="method"><code id='default.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Default.html#tymethod.default' class='fnname'>default</a>() -&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#177-179' title='goto source code'>[src]</a></h4><div class='docblock'><p>Creates an empty <code>VecDeque&lt;T&gt;</code>.</p>
</div></div><h3 id='impl-Drop' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Drop.html" title="trait nom::lib::std::prelude::v1::v1::Drop">Drop</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a href='#impl-Drop' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#149-171' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.drop' class="method hidden"><code id='drop.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Drop.html#tymethod.drop' class='fnname'>drop</a>(&amp;mut self)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#150-170' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Executes the destructor for this type. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Drop.html#tymethod.drop">Read more</a></p>
</div></div><h3 id='impl-Eq' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Eq.html" title="trait nom::lib::std::prelude::v1::v1::Eq">Eq</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Eq.html" title="trait nom::lib::std::prelude::v1::v1::Eq">Eq</a>,&nbsp;</span></code><a href='#impl-Eq' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2589' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-Extend%3C%26%27a%20T%3E' class='impl'><code class='in-band'>impl&lt;'a, T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Extend.html" title="trait nom::lib::std::prelude::v1::v1::Extend">Extend</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'a </a>T&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: 'a + <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Copy.html" title="trait nom::lib::std::prelude::v1::v1::Copy">Copy</a>,&nbsp;</span></code><a href='#impl-Extend%3C%26%27a%20T%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.2.0'>1.2.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2729-2733' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.extend-1' class="method hidden"><code id='extend.v-1'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Extend.html#tymethod.extend' class='fnname'>extend</a>&lt;I&gt;(&amp;mut self, iter: I) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;I: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html" title="trait nom::lib::std::prelude::v1::v1::IntoIterator">IntoIterator</a>&lt;Item = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'a </a>T&gt;,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2730-2732' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Extends a collection with the contents of an iterator. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Extend.html#tymethod.extend">Read more</a></p>
</div></div><h3 id='impl-Extend%3CA%3E' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Extend.html" title="trait nom::lib::std::prelude::v1::v1::Extend">Extend</a>&lt;A&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;</code><a href='#impl-Extend%3CA%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2705-2726' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.extend' class="method hidden"><code id='extend.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Extend.html#tymethod.extend' class='fnname'>extend</a>&lt;T&gt;(&amp;mut self, iter: T) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html" title="trait nom::lib::std::prelude::v1::v1::IntoIterator">IntoIterator</a>&lt;Item = A&gt;,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2706-2725' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Extends a collection with the contents of an iterator. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Extend.html#tymethod.extend">Read more</a></p>
</div></div><h3 id='impl-From%3CVec%3CT%3E%3E' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.From.html" title="trait nom::lib::std::prelude::v1::v1::From">From</a>&lt;<a class="struct" href="../../../../nom/lib/std/prelude/v1/v1/struct.Vec.html" title="struct nom::lib::std::prelude::v1::v1::Vec">Vec</a>&lt;T&gt;&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a href='#impl-From%3CVec%3CT%3E%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.10.0'>1.10.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2743-2772' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from' class="method"><code id='from.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.From.html#tymethod.from' class='fnname'>from</a>(other: <a class="struct" href="../../../../nom/lib/std/prelude/v1/v1/struct.Vec.html" title="struct nom::lib::std::prelude::v1::v1::Vec">Vec</a>&lt;T&gt;) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2752-2771' title='goto source code'>[src]</a></h4><div class='docblock'><p>Turn a <a href="crate::vec::Vec"><code>Vec&lt;T&gt;</code></a> into a <a href="crate::collections::VecDeque"><code>VecDeque&lt;T&gt;</code></a>.</p>
<p>This avoids reallocating where possible, but the conditions for that are
strict, and subject to change, and so shouldn't be relied upon unless the
<code>Vec&lt;T&gt;</code> came from <code>From&lt;VecDeque&lt;T&gt;&gt;</code> and hasn't been reallocated.</p>
</div></div><h3 id='impl-From%3CVecDeque%3CT%3E%3E' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.From.html" title="trait nom::lib::std::prelude::v1::v1::From">From</a>&lt;<a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;&gt; for <a class="struct" href="../../../../nom/lib/std/prelude/v1/v1/struct.Vec.html" title="struct nom::lib::std::prelude::v1::v1::Vec">Vec</a>&lt;T&gt;</code><a href='#impl-From%3CVecDeque%3CT%3E%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.10.0'>1.10.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2775-2868' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from-1' class="method"><code id='from.v-1'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.From.html#tymethod.from' class='fnname'>from</a>(other: <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;) -&gt; <a class="struct" href="../../../../nom/lib/std/prelude/v1/v1/struct.Vec.html" title="struct nom::lib::std::prelude::v1::v1::Vec">Vec</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2805-2867' title='goto source code'>[src]</a></h4><div class='docblock'><p>Turn a <a href="crate::collections::VecDeque"><code>VecDeque&lt;T&gt;</code></a> into a <a href="crate::vec::Vec"><code>Vec&lt;T&gt;</code></a>.</p>
<p>This never needs to re-allocate, but does need to do O(n) data movement if
the circular buffer doesn't happen to be at the beginning of the allocation.</p>
<h1 id="examples-41" class="section-header"><a href="#examples-41">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">VecDeque</span>;
<span class="comment">// This one is O(1).</span>
<span class="kw">let</span> <span class="ident">deque</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span> <span class="op">=</span> (<span class="number">1</span>..<span class="number">5</span>).<span class="ident">collect</span>();
<span class="kw">let</span> <span class="ident">ptr</span> <span class="op">=</span> <span class="ident">deque</span>.<span class="ident">as_slices</span>().<span class="number">0</span>.<span class="ident">as_ptr</span>();
<span class="kw">let</span> <span class="ident">vec</span> <span class="op">=</span> <span class="ident">Vec</span>::<span class="ident">from</span>(<span class="ident">deque</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vec</span>, [<span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vec</span>.<span class="ident">as_ptr</span>(), <span class="ident">ptr</span>);
<span class="comment">// This one needs data rearranging.</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">deque</span>: <span class="ident">VecDeque</span><span class="op">&lt;</span><span class="kw">_</span><span class="op">&gt;</span> <span class="op">=</span> (<span class="number">1</span>..<span class="number">5</span>).<span class="ident">collect</span>();
<span class="ident">deque</span>.<span class="ident">push_front</span>(<span class="number">9</span>);
<span class="ident">deque</span>.<span class="ident">push_front</span>(<span class="number">8</span>);
<span class="kw">let</span> <span class="ident">ptr</span> <span class="op">=</span> <span class="ident">deque</span>.<span class="ident">as_slices</span>().<span class="number">1</span>.<span class="ident">as_ptr</span>();
<span class="kw">let</span> <span class="ident">vec</span> <span class="op">=</span> <span class="ident">Vec</span>::<span class="ident">from</span>(<span class="ident">deque</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vec</span>, [<span class="number">8</span>, <span class="number">9</span>, <span class="number">1</span>, <span class="number">2</span>, <span class="number">3</span>, <span class="number">4</span>]);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">vec</span>.<span class="ident">as_ptr</span>(), <span class="ident">ptr</span>);</pre></div>
</div></div><h3 id='impl-FromIterator%3CA%3E' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/iter/trait.FromIterator.html" title="trait nom::lib::std::iter::FromIterator">FromIterator</a>&lt;A&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;</code><a href='#impl-FromIterator%3CA%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2662-2670' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from_iter' class="method hidden"><code id='from_iter.v'>fn <a href='../../../../nom/lib/std/iter/trait.FromIterator.html#tymethod.from_iter' class='fnname'>from_iter</a>&lt;T&gt;(iter: T) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html" title="trait nom::lib::std::prelude::v1::v1::IntoIterator">IntoIterator</a>&lt;Item = A&gt;,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2663-2669' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates a value from an iterator. <a href="../../../../nom/lib/std/iter/trait.FromIterator.html#tymethod.from_iter">Read more</a></p>
</div></div><h3 id='impl-Hash' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/hash/trait.Hash.html" title="trait nom::lib::std::hash::Hash">Hash</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/hash/trait.Hash.html" title="trait nom::lib::std::hash::Hash">Hash</a>,&nbsp;</span></code><a href='#impl-Hash' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2634-2641' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.hash' class="method hidden"><code id='hash.v'>fn <a href='../../../../nom/lib/std/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a>&lt;H&gt;(&amp;self, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>H) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;H: <a class="trait" href="../../../../nom/lib/std/hash/trait.Hasher.html" title="trait nom::lib::std::hash::Hasher">Hasher</a>,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2635-2640' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Feeds this value into the given [<code>Hasher</code>]. <a href="../../../../nom/lib/std/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
</div><h4 id='method.hash_slice' class="method hidden"><code id='hash_slice.v'>fn <a href='../../../../nom/lib/std/hash/trait.Hash.html#method.hash_slice' class='fnname'>hash_slice</a>&lt;H&gt;(data: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[Self]</a>, state: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>H) <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;H: <a class="trait" href="../../../../nom/lib/std/hash/trait.Hasher.html" title="trait nom::lib::std::hash::Hasher">Hasher</a>,&nbsp;</span></code><span class='since' title='Stable since Rust version 1.3.0'>1.3.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/hash/mod.rs.html#194-201' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Feeds a slice of this type into the given [<code>Hasher</code>]. <a href="../../../../nom/lib/std/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
</div></div><h3 id='impl-Index%3Cusize%3E' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/ops/trait.Index.html" title="trait nom::lib::std::ops::Index">Index</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;</code><a href='#impl-Index%3Cusize%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2644-2651' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Output' class="type"><code id='Output.t'>type <a href='../../../../nom/lib/std/ops/trait.Index.html#associatedtype.Output' class="type">Output</a> = A</code></h4><div class='docblock'><p>The returned type after indexing.</p>
</div><h4 id='method.index' class="method hidden"><code id='index.v'>fn <a href='../../../../nom/lib/std/ops/trait.Index.html#tymethod.index' class='fnname'>index</a>(&amp;self, index: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>A</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2648-2650' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the indexing (<code>container[index]</code>) operation.</p>
</div></div><h3 id='impl-IndexMut%3Cusize%3E' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/ops/trait.IndexMut.html" title="trait nom::lib::std::ops::IndexMut">IndexMut</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;</code><a href='#impl-IndexMut%3Cusize%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2654-2659' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.index_mut' class="method hidden"><code id='index_mut.v'>fn <a href='../../../../nom/lib/std/ops/trait.IndexMut.html#tymethod.index_mut' class='fnname'>index_mut</a>(&amp;mut self, index: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>A</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2656-2658' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the mutable indexing (<code>container[index]</code>) operation.</p>
</div></div><h3 id='impl-IntoIterator' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html" title="trait nom::lib::std::prelude::v1::v1::IntoIterator">IntoIterator</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a href='#impl-IntoIterator' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2673-2682' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Item' class="type"><code id='Item.t'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#associatedtype.Item' class="type">Item</a> = T</code></h4><div class='docblock'><p>The type of the elements being iterated over.</p>
</div><h4 id='associatedtype.IntoIter' class="type"><code id='IntoIter.t'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#associatedtype.IntoIter' class="type">IntoIter</a> = <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.IntoIter.html" title="struct nom::lib::std::collections::vec_deque::IntoIter">IntoIter</a>&lt;T&gt;</code></h4><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div><h4 id='method.into_iter' class="method"><code id='into_iter.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.IntoIter.html" title="struct nom::lib::std::collections::vec_deque::IntoIter">IntoIter</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2679-2681' title='goto source code'>[src]</a></h4><div class='docblock'><p>Consumes the <code>VecDeque</code> into a front-to-back iterator yielding elements by
value.</p>
</div></div><h3 id='impl-IntoIterator-1' class='impl'><code class='in-band'>impl&lt;'a, T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html" title="trait nom::lib::std::prelude::v1::v1::IntoIterator">IntoIterator</a> for &amp;'a <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a href='#impl-IntoIterator-1' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2685-2692' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Item-1' class="type"><code id='Item.t-1'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'a </a>T</code></h4><div class='docblock'><p>The type of the elements being iterated over.</p>
</div><h4 id='associatedtype.IntoIter-1' class="type"><code id='IntoIter.t-1'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#associatedtype.IntoIter' class="type">IntoIter</a> = <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.Iter.html" title="struct nom::lib::std::collections::vec_deque::Iter">Iter</a>&lt;'a, T&gt;</code></h4><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div><h4 id='method.into_iter-1' class="method hidden"><code id='into_iter.v-1'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.Iter.html" title="struct nom::lib::std::collections::vec_deque::Iter">Iter</a>&lt;'a, T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2689-2691' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates an iterator from a value. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></div><h3 id='impl-IntoIterator-2' class='impl'><code class='in-band'>impl&lt;'a, T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html" title="trait nom::lib::std::prelude::v1::v1::IntoIterator">IntoIterator</a> for &amp;'a mut <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt;</code><a href='#impl-IntoIterator-2' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2695-2702' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Item-2' class="type"><code id='Item.t-2'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#associatedtype.Item' class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;'a mut </a>T</code></h4><div class='docblock'><p>The type of the elements being iterated over.</p>
</div><h4 id='associatedtype.IntoIter-2' class="type"><code id='IntoIter.t-2'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#associatedtype.IntoIter' class="type">IntoIter</a> = <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.IterMut.html" title="struct nom::lib::std::collections::vec_deque::IterMut">IterMut</a>&lt;'a, T&gt;</code></h4><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div><h4 id='method.into_iter-2' class="method hidden"><code id='into_iter.v-2'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -&gt; <a class="struct" href="../../../../nom/lib/std/collections/vec_deque/struct.IterMut.html" title="struct nom::lib::std::collections::vec_deque::IterMut">IterMut</a>&lt;'a, T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2699-2701' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates an iterator from a value. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></div><h3 id='impl-Ord' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html" title="trait nom::lib::std::prelude::v1::v1::Ord">Ord</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html" title="trait nom::lib::std::prelude::v1::v1::Ord">Ord</a>,&nbsp;</span></code><a href='#impl-Ord' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2626-2631' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.cmp' class="method hidden"><code id='cmp.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html#tymethod.cmp' class='fnname'>cmp</a>(&amp;self, other: &amp;<a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;) -&gt; <a class="enum" href="../../../../nom/lib/std/cmp/enum.Ordering.html" title="enum nom::lib::std::cmp::Ordering">Ordering</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2628-2630' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method returns an [<code>Ordering</code>] between <code>self</code> and <code>other</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html#tymethod.cmp">Read more</a></p>
</div><h4 id='method.max' class="method hidden"><code id='max.v'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html#method.max' class='fnname'>max</a>(self, other: Self) -&gt; Self</code><span class='since' title='Stable since Rust version 1.21.0'>1.21.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#599-604' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Compares and returns the maximum of two values. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html#method.max">Read more</a></p>
</div><h4 id='method.min' class="method hidden"><code id='min.v'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html#method.min' class='fnname'>min</a>(self, other: Self) -&gt; Self</code><span class='since' title='Stable since Rust version 1.21.0'>1.21.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#619-624' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Compares and returns the minimum of two values. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html#method.min">Read more</a></p>
</div><h4 id='method.clamp' class="method hidden"><code id='clamp.v'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html#method.clamp' class='fnname'>clamp</a>(self, min: Self, max: Self) -&gt; Self</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#646-658' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab unstable'><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>clamp</code>)</div></div><div class='docblock hidden'><p>Restrict a value to a certain interval. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.Ord.html#method.clamp">Read more</a></p>
</div></div><h3 id='impl-PartialEq%3C%26%27_%20%5BB%3B%20N%5D%3E' class='impl'><code class='in-band'>impl&lt;'_, const N:&nbsp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, A, B&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;&amp;'_ <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;B&gt;,<br>&nbsp;&nbsp;&nbsp;&nbsp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/array/trait.LengthAtMost32.html" title="trait core::array::LengthAtMost32">LengthAtMost32</a>,&nbsp;</span></code><a href='#impl-PartialEq%3C%26%27_%20%5BB%3B%20N%5D%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.17.0'>1.17.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2594-2607' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq' class="method hidden"><code id='eq.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, other: &amp;&amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2599-2606' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne' class="method hidden"><code id='ne.v'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#215-217' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-PartialEq%3C%26%27_%20%5BB%5D%3E' class='impl'><code class='in-band'>impl&lt;'_, A, B&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;'_ [B]</a>&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;B&gt;,&nbsp;</span></code><a href='#impl-PartialEq%3C%26%27_%20%5BB%5D%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.17.0'>1.17.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2594-2607' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq-2' class="method hidden"><code id='eq.v-2'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, other: &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;[B]</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2599-2606' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne-2' class="method hidden"><code id='ne.v-2'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#215-217' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-PartialEq%3C%26%27_%20mut%20%5BB%3B%20N%5D%3E' class='impl'><code class='in-band'>impl&lt;'_, const N:&nbsp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, A, B&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;&amp;'_ mut <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;B&gt;,<br>&nbsp;&nbsp;&nbsp;&nbsp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/array/trait.LengthAtMost32.html" title="trait core::array::LengthAtMost32">LengthAtMost32</a>,&nbsp;</span></code><a href='#impl-PartialEq%3C%26%27_%20mut%20%5BB%3B%20N%5D%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.17.0'>1.17.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2594-2607' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq-1' class="method hidden"><code id='eq.v-1'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, other: &amp;&amp;mut <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2599-2606' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne-1' class="method hidden"><code id='ne.v-1'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#215-217' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-PartialEq%3C%26%27_%20mut%20%5BB%5D%3E' class='impl'><code class='in-band'>impl&lt;'_, A, B&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;'_ mut [B]</a>&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;B&gt;,&nbsp;</span></code><a href='#impl-PartialEq%3C%26%27_%20mut%20%5BB%5D%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.17.0'>1.17.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2594-2607' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq-5' class="method hidden"><code id='eq.v-5'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, other: &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.slice.html">&amp;mut [B]</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2599-2606' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne-5' class="method hidden"><code id='ne.v-5'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#215-217' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-PartialEq%3C%5BB%3B%20N%5D%3E' class='impl'><code class='in-band'>impl&lt;const N:&nbsp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.usize.html">usize</a>, A, B&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;B&gt;,<br>&nbsp;&nbsp;&nbsp;&nbsp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>: <a class="trait" href="https://doc.rust-lang.org/nightly/core/array/trait.LengthAtMost32.html" title="trait core::array::LengthAtMost32">LengthAtMost32</a>,&nbsp;</span></code><a href='#impl-PartialEq%3C%5BB%3B%20N%5D%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.17.0'>1.17.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2594-2607' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq-6' class="method hidden"><code id='eq.v-6'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, other: &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">[</a>B<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.array.html">; N]</a>) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2599-2606' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne-6' class="method hidden"><code id='ne.v-6'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#215-217' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-PartialEq%3CVec%3CB%3E%3E' class='impl'><code class='in-band'>impl&lt;A, B&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;<a class="struct" href="../../../../nom/lib/std/prelude/v1/v1/struct.Vec.html" title="struct nom::lib::std::prelude::v1::v1::Vec">Vec</a>&lt;B&gt;&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;B&gt;,&nbsp;</span></code><a href='#impl-PartialEq%3CVec%3CB%3E%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.17.0'>1.17.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2594-2607' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq-3' class="method hidden"><code id='eq.v-3'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, other: &amp;<a class="struct" href="../../../../nom/lib/std/prelude/v1/v1/struct.Vec.html" title="struct nom::lib::std::prelude::v1::v1::Vec">Vec</a>&lt;B&gt;) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2599-2606' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne-3' class="method hidden"><code id='ne.v-3'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#215-217' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-PartialEq%3CVecDeque%3CA%3E%3E' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;<a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html" title="trait nom::lib::std::prelude::v1::v1::PartialEq">PartialEq</a>&lt;A&gt;,&nbsp;</span></code><a href='#impl-PartialEq%3CVecDeque%3CA%3E%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2550-2586' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.eq-4' class="method hidden"><code id='eq.v-4'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&amp;self, other: &amp;<a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2551-2585' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne-4' class="method hidden"><code id='ne.v-4'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#215-217' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-PartialOrd%3CVecDeque%3CA%3E%3E' class='impl'><code class='in-band'>impl&lt;A&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html" title="trait nom::lib::std::prelude::v1::v1::PartialOrd">PartialOrd</a>&lt;<a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;&gt; for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;A: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html" title="trait nom::lib::std::prelude::v1::v1::PartialOrd">PartialOrd</a>&lt;A&gt;,&nbsp;</span></code><a href='#impl-PartialOrd%3CVecDeque%3CA%3E%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2619-2623' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.partial_cmp' class="method hidden"><code id='partial_cmp.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#tymethod.partial_cmp' class='fnname'>partial_cmp</a>(&amp;self, other: &amp;<a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;A&gt;) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;<a class="enum" href="../../../../nom/lib/std/cmp/enum.Ordering.html" title="enum nom::lib::std::cmp::Ordering">Ordering</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/collections/vec_deque.rs.html#2620-2622' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method returns an ordering between <code>self</code> and <code>other</code> values if one exists. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#tymethod.partial_cmp">Read more</a></p>
</div><h4 id='method.lt' class="method hidden"><code id='lt.v'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.lt' class='fnname'>lt</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#841-843' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests less than (for <code>self</code> and <code>other</code>) and is used by the <code>&lt;</code> operator. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.lt">Read more</a></p>
</div><h4 id='method.le' class="method hidden"><code id='le.v'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.le' class='fnname'>le</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#860-862' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests less than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>&lt;=</code> operator. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.le">Read more</a></p>
</div><h4 id='method.gt' class="method hidden"><code id='gt.v'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.gt' class='fnname'>gt</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#878-880' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests greater than (for <code>self</code> and <code>other</code>) and is used by the <code>&gt;</code> operator. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.gt">Read more</a></p>
</div><h4 id='method.ge' class="method hidden"><code id='ge.v'><span class="docblock attributes">#[must_use]
</span>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.ge' class='fnname'>ge</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>Rhs) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.bool.html">bool</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/cmp.rs.html#897-899' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>This method tests greater than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>&gt;=</code> operator. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.ge">Read more</a></p>
</div></div></div><h2 id='synthetic-implementations' class='small-section-header'>Auto Trait Implementations<a href='#synthetic-implementations' class='anchor'></a></h2><div id='synthetic-implementations-list'><h3 id='impl-RefUnwindSafe' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a>,&nbsp;</span></code><a href='#impl-RefUnwindSafe' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Send' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Send.html" title="trait nom::lib::std::prelude::v1::v1::Send">Send</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Send.html" title="trait nom::lib::std::prelude::v1::v1::Send">Send</a>,&nbsp;</span></code><a href='#impl-Send' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Sync' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Sync.html" title="trait nom::lib::std::prelude::v1::v1::Sync">Sync</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Sync.html" title="trait nom::lib::std::prelude::v1::v1::Sync">Sync</a>,&nbsp;</span></code><a href='#impl-Sync' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-Unpin' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Unpin.html" title="trait nom::lib::std::prelude::v1::v1::Unpin">Unpin</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Unpin.html" title="trait nom::lib::std::prelude::v1::v1::Unpin">Unpin</a>,&nbsp;</span></code><a href='#impl-Unpin' class='anchor'></a></h3><div class='impl-items'></div><h3 id='impl-UnwindSafe' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a> for <a class="struct" href="../../../../nom/lib/std/collections/struct.VecDeque.html" title="struct nom::lib::std::collections::VecDeque">VecDeque</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="https://doc.rust-lang.org/nightly/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>,&nbsp;</span></code><a href='#impl-UnwindSafe' class='anchor'></a></h3><div class='impl-items'></div></div><h2 id='blanket-implementations' class='small-section-header'>Blanket Implementations<a href='#blanket-implementations' class='anchor'></a></h2><div id='blanket-implementations-list'><h3 id='impl-Any' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: 'static + ?<a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Sized.html" title="trait nom::lib::std::prelude::v1::v1::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-Any' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#108-112' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.type_id' class="method hidden"><code id='type_id.v'>fn <a href='https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id' class='fnname'>type_id</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/nightly/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/any.rs.html#109-111' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/nightly/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></div><h3 id='impl-Borrow%3CT%3E' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;T&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Sized.html" title="trait nom::lib::std::prelude::v1::v1::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-Borrow%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#213-217' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow' class="method hidden"><code id='borrow.v'>fn <a href='https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow' class='fnname'>borrow</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#214-216' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></div><h3 id='impl-BorrowMut%3CT%3E' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a>&lt;T&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Sized.html" title="trait nom::lib::std::prelude::v1::v1::Sized">Sized</a>,&nbsp;</span></code><a href='#impl-BorrowMut%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#220-224' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.borrow_mut' class="method hidden"><code id='borrow_mut.v'>fn <a href='https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut' class='fnname'>borrow_mut</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/borrow.rs.html#221-223' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/nightly/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
</div></div><h3 id='impl-From%3CT%3E' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.From.html" title="trait nom::lib::std::prelude::v1::v1::From">From</a>&lt;T&gt; for T</code><a href='#impl-From%3CT%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#564-568' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from-2' class="method hidden"><code id='from.v-2'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.From.html#tymethod.from' class='fnname'>from</a>(t: T) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#565-567' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-Into%3CU%3E' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Into.html" title="trait nom::lib::std::prelude::v1::v1::Into">Into</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.From.html" title="trait nom::lib::std::prelude::v1::v1::From">From</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-Into%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#553-560' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.into' class="method hidden"><code id='into.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.Into.html#tymethod.into' class='fnname'>into</a>(self) -&gt; U</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#557-559' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-IntoIterator-3' class='impl'><code class='in-band'>impl&lt;I&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html" title="trait nom::lib::std::prelude::v1::v1::IntoIterator">IntoIterator</a> for I <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;I: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Iterator.html" title="trait nom::lib::std::prelude::v1::v1::Iterator">Iterator</a>,&nbsp;</span></code><a href='#impl-IntoIterator-3' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#243-250' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Item-3' class="type"><code id='Item.t-3'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#associatedtype.Item' class="type">Item</a> = &lt;I as <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Iterator.html" title="trait nom::lib::std::prelude::v1::v1::Iterator">Iterator</a>&gt;::<a class="type" href="../../../../nom/lib/std/prelude/v1/v1/trait.Iterator.html#associatedtype.Item" title="type nom::lib::std::prelude::v1::v1::Iterator::Item">Item</a></code></h4><div class='docblock'><p>The type of the elements being iterated over.</p>
</div><h4 id='associatedtype.IntoIter-3' class="type"><code id='IntoIter.t-3'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#associatedtype.IntoIter' class="type">IntoIter</a> = I</code></h4><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div><h4 id='method.into_iter-3' class="method hidden"><code id='into_iter.v-3'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#tymethod.into_iter' class='fnname'>into_iter</a>(self) -&gt; I</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/iter/traits/collect.rs.html#247-249' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates an iterator from a value. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></div><h3 id='impl-ToOwned' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.ToOwned.html" title="trait nom::lib::std::prelude::v1::v1::ToOwned">ToOwned</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Clone.html" title="trait nom::lib::std::prelude::v1::v1::Clone">Clone</a>,&nbsp;</span></code><a href='#impl-ToOwned' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#80-92' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Owned' class="type"><code id='Owned.t'>type <a href='../../../../nom/lib/std/prelude/v1/v1/trait.ToOwned.html#associatedtype.Owned' class="type">Owned</a> = T</code></h4><div class='docblock'><p>The resulting type after obtaining ownership.</p>
</div><h4 id='method.to_owned' class="method hidden"><code id='to_owned.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.ToOwned.html#tymethod.to_owned' class='fnname'>to_owned</a>(&amp;self) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#85-87' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Creates owned data from borrowed data, usually by cloning. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.ToOwned.html#tymethod.to_owned">Read more</a></p>
</div><h4 id='method.clone_into' class="method hidden"><code id='clone_into.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.ToOwned.html#method.clone_into' class='fnname'>clone_into</a>(&amp;self, target: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/alloc/borrow.rs.html#89-91' title='goto source code'>[src]</a></h4><div class='stability hidden'><div class='stab unstable'><details><summary><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>toowned_clone_into</code>)</summary><p>recently added</p>
</details></div></div><div class='docblock hidden'><p>Uses borrowed data to replace owned data, usually by cloning. <a href="../../../../nom/lib/std/prelude/v1/v1/trait.ToOwned.html#method.clone_into">Read more</a></p>
</div></div><h3 id='impl-TryFrom%3CU%3E' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="../../../../nom/lib/std/convert/trait.TryFrom.html" title="trait nom::lib::std::convert::TryFrom">TryFrom</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Into.html" title="trait nom::lib::std::prelude::v1::v1::Into">Into</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-TryFrom%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#601-610' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error' class="type"><code id='Error.t'>type <a href='../../../../nom/lib/std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="enum" href="../../../../nom/lib/std/convert/enum.Infallible.html" title="enum nom::lib::std::convert::Infallible">Infallible</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from' class="method hidden"><code id='try_from.v'>fn <a href='../../../../nom/lib/std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(value: U) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Result.html" title="enum nom::lib::std::prelude::v1::v1::Result">Result</a>&lt;T, &lt;T as <a class="trait" href="../../../../nom/lib/std/convert/trait.TryFrom.html" title="trait nom::lib::std::convert::TryFrom">TryFrom</a>&lt;U&gt;&gt;::<a class="type" href="../../../../nom/lib/std/convert/trait.TryFrom.html#associatedtype.Error" title="type nom::lib::std::convert::TryFrom::Error">Error</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#607-609' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-TryInto%3CU%3E' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="../../../../nom/lib/std/convert/trait.TryInto.html" title="trait nom::lib::std::convert::TryInto">TryInto</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="../../../../nom/lib/std/convert/trait.TryFrom.html" title="trait nom::lib::std::convert::TryFrom">TryFrom</a>&lt;T&gt;,&nbsp;</span></code><a href='#impl-TryInto%3CU%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#587-596' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Error-1' class="type"><code id='Error.t-1'>type <a href='../../../../nom/lib/std/convert/trait.TryInto.html#associatedtype.Error' class="type">Error</a> = &lt;U as <a class="trait" href="../../../../nom/lib/std/convert/trait.TryFrom.html" title="trait nom::lib::std::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="type" href="../../../../nom/lib/std/convert/trait.TryFrom.html#associatedtype.Error" title="type nom::lib::std::convert::TryFrom::Error">Error</a></code></h4><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_into' class="method hidden"><code id='try_into.v'>fn <a href='../../../../nom/lib/std/convert/trait.TryInto.html#tymethod.try_into' class='fnname'>try_into</a>(self) -&gt; <a class="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Result.html" title="enum nom::lib::std::prelude::v1::v1::Result">Result</a>&lt;U, &lt;U as <a class="trait" href="../../../../nom/lib/std/convert/trait.TryFrom.html" title="trait nom::lib::std::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="type" href="../../../../nom/lib/std/convert/trait.TryFrom.html#associatedtype.Error" title="type nom::lib::std::convert::TryFrom::Error">Error</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#593-595' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div></div></section><section id="search" class="content hidden"></section><section class="footer"></section><script>window.rootPath = "../../../../";window.currentCrate = "nom";</script><script src="../../../../aliases.js"></script><script src="../../../../main.js"></script><script defer src="../../../../search-index.js"></script></body></html>
Reference in New Issue View Git Blame Copy Permalink