Mercator/mercator_service
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Files
527969729d50e57b483610ffacaa016c42441eac
mercator_service/nom/lib/std/option/enum.Option.html

620 lines
171 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 `Option` enum in crate `nom`."><meta name="keywords" content="rust, rustlang, rust-lang, Option"><title>nom::lib::std::option::Option - 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 enum"><!--[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'>Enum Option</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#variants">Variants</a><div class="sidebar-links"><a href="#variant.None">None</a><a href="#variant.Some">Some</a></div><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.and">and</a><a href="#method.and_then">and_then</a><a href="#method.as_deref">as_deref</a><a href="#method.as_deref_mut">as_deref_mut</a><a href="#method.as_mut">as_mut</a><a href="#method.as_pin_mut">as_pin_mut</a><a href="#method.as_pin_ref">as_pin_ref</a><a href="#method.as_ref">as_ref</a><a href="#method.cloned">cloned</a><a href="#method.cloned-1">cloned</a><a href="#method.contains">contains</a><a href="#method.copied">copied</a><a href="#method.copied-1">copied</a><a href="#method.expect">expect</a><a href="#method.expect_none">expect_none</a><a href="#method.filter">filter</a><a href="#method.flatten">flatten</a><a href="#method.get_or_insert">get_or_insert</a><a href="#method.get_or_insert_with">get_or_insert_with</a><a href="#method.is_none">is_none</a><a href="#method.is_some">is_some</a><a href="#method.iter">iter</a><a href="#method.iter_mut">iter_mut</a><a href="#method.map">map</a><a href="#method.map_or">map_or</a><a href="#method.map_or_else">map_or_else</a><a href="#method.ok_or">ok_or</a><a href="#method.ok_or_else">ok_or_else</a><a href="#method.or">or</a><a href="#method.or_else">or_else</a><a href="#method.replace">replace</a><a href="#method.take">take</a><a href="#method.transpose">transpose</a><a href="#method.unwrap">unwrap</a><a href="#method.unwrap_none">unwrap_none</a><a href="#method.unwrap_or">unwrap_or</a><a href="#method.unwrap_or_default">unwrap_or_default</a><a href="#method.unwrap_or_else">unwrap_or_else</a><a href="#method.xor">xor</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Clone">Clone</a><a href="#impl-Copy">Copy</a><a href="#impl-Debug">Debug</a><a href="#impl-Default">Default</a><a href="#impl-Eq">Eq</a><a href="#impl-From%3C%26%27a%20Option%3CT%3E%3E">From&lt;&amp;&#39;a Option&lt;T&gt;&gt;</a><a href="#impl-From%3C%26%27a%20mut%20Option%3CT%3E%3E">From&lt;&amp;&#39;a mut Option&lt;T&gt;&gt;</a><a href="#impl-From%3CT%3E">From&lt;T&gt;</a><a href="#impl-FromIterator%3COption%3CA%3E%3E">FromIterator&lt;Option&lt;A&gt;&gt;</a><a href="#impl-Hash">Hash</a><a href="#impl-IntoIterator">IntoIterator</a><a href="#impl-Ord">Ord</a><a href="#impl-PartialEq%3COption%3CT%3E%3E">PartialEq&lt;Option&lt;T&gt;&gt;</a><a href="#impl-PartialOrd%3COption%3CT%3E%3E">PartialOrd&lt;Option&lt;T&gt;&gt;</a><a href="#impl-Product%3COption%3CU%3E%3E">Product&lt;Option&lt;U&gt;&gt;</a><a href="#impl-StructuralEq">StructuralEq</a><a href="#impl-StructuralPartialEq">StructuralPartialEq</a><a href="#impl-Sum%3COption%3CU%3E%3E">Sum&lt;Option&lt;U&gt;&gt;</a><a href="#impl-Try">Try</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%3C!%3E">From&lt;!&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'>option</a></p><script>window.sidebarCurrent = {name: 'Option', ty: 'enum', 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/core/option.rs.html#156-163' title='goto source code'>[src]</a></span><span class='in-band'>Enum <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'>option</a>::<wbr><a class="enum" href=''>Option</a></span></h1><div class="docblock type-decl hidden-by-usual-hider"><pre class='rust enum'>pub enum Option&lt;T&gt; {
None,
Some(T),
}</pre></div><div class='docblock'><p>The <code>Option</code> type. See <a href="index.html">the module level documentation</a> for more.</p>
</div><h2 id='variants' class='variants small-section-header'>
Variants<a href='#variants' class='anchor'></a></h2>
<div id="variant.None" class="variant small-section-header"><a href="#variant.None" class="anchor field"></a><code id='None.v'>None</code></div><div class='docblock'><p>No value</p>
</div><div id="variant.Some" class="variant small-section-header"><a href="#variant.Some" class="anchor field"></a><code id='Some.v'>Some(T)</code></div><div class='docblock'><p>Some value <code>T</code></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="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 href='#impl' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#169-916' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.is_some' class="method"><code id='is_some.v'><span class="docblock attributes">#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"]
</span>pub fn <a href='#method.is_some' class='fnname'>is_some</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/core/option.rs.html#190-192' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <code>true</code> if the option is a <a href="#variant.Some"><code>Some</code></a> value.</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">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</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">x</span>.<span class="ident">is_some</span>(), <span class="bool-val">true</span>);
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">is_some</span>(), <span class="bool-val">false</span>);</pre></div>
</div><h4 id='method.is_none' class="method"><code id='is_none.v'><span class="docblock attributes">#[must_use = "if you intended to assert that this doesn\'t have a value, consider `.and_then(|| panic!(\"`Option` had a value when expected `None`\"))` instead"]
</span>pub fn <a href='#method.is_none' class='fnname'>is_none</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/core/option.rs.html#211-213' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <code>true</code> if the option is a <a href="#variant.None"><code>None</code></a> value.</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">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</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">x</span>.<span class="ident">is_none</span>(), <span class="bool-val">false</span>);
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">is_none</span>(), <span class="bool-val">true</span>);</pre></div>
</div><h4 id='method.contains' class="method"><code id='contains.v'><span class="docblock attributes">#[must_use]
</span>pub fn <a href='#method.contains' class='fnname'>contains</a>&lt;U&gt;(&amp;self, x: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>U) -&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;U: <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><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#234-242' title='goto source code'>[src]</a></h4><div class='stability'><div class='stab unstable'><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>option_result_contains</code>)</div></div><div class='docblock'><p>Returns <code>true</code> if the option is a [<code>Some</code>] value containing the given value.</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="attribute">#![<span class="ident">feature</span>(<span class="ident">option_result_contains</span>)]</span>
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</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">x</span>.<span class="ident">contains</span>(<span class="kw-2">&amp;</span><span class="number">2</span>), <span class="bool-val">true</span>);
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</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">x</span>.<span class="ident">contains</span>(<span class="kw-2">&amp;</span><span class="number">2</span>), <span class="bool-val">false</span>);
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">contains</span>(<span class="kw-2">&amp;</span><span class="number">2</span>), <span class="bool-val">false</span>);</pre></div>
</div><h4 id='method.as_ref' class="method"><code id='as_ref.v'>pub fn <a href='#method.as_ref' class='fnname'>as_ref</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/core/option.rs.html#270-275' title='goto source code'>[src]</a></h4><div class='docblock'><p>Converts from <code>&amp;Option&lt;T&gt;</code> to <code>Option&lt;&amp;T&gt;</code>.</p>
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
<p>Converts an <code>Option&lt;</code><a href="../../std/string/struct.String.html"><code>String</code></a><code>&gt;</code> into an <code>Option&lt;</code><a href="../../std/primitive.usize.html"><code>usize</code></a><code>&gt;</code>, preserving the original.
The <a href="enum.Option.html#method.map"><code>map</code></a> method takes the <code>self</code> argument by value, consuming the original,
so this technique uses <code>as_ref</code> to first take an <code>Option</code> to a reference
to the value inside the original.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">text</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">String</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;Hello, world!&quot;</span>.<span class="ident">to_string</span>());
<span class="comment">// First, cast `Option&lt;String&gt;` to `Option&lt;&amp;String&gt;` with `as_ref`,</span>
<span class="comment">// then consume *that* with `map`, leaving `text` on the stack.</span>
<span class="kw">let</span> <span class="ident">text_length</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">usize</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">text</span>.<span class="ident">as_ref</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">s</span><span class="op">|</span> <span class="ident">s</span>.<span class="ident">len</span>());
<span class="macro">println</span><span class="macro">!</span>(<span class="string">&quot;still can print text: {:?}&quot;</span>, <span class="ident">text</span>);</pre></div>
</div><h4 id='method.as_mut' class="method"><code id='as_mut.v'>pub fn <a href='#method.as_mut' class='fnname'>as_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/core/option.rs.html#291-296' title='goto source code'>[src]</a></h4><div class='docblock'><p>Converts from <code>&amp;mut Option&lt;T&gt;</code> to <code>Option&lt;&amp;mut T&gt;</code>.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">match</span> <span class="ident">x</span>.<span class="ident">as_mut</span>() {
<span class="prelude-val">Some</span>(<span class="ident">v</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="kw-2">*</span><span class="ident">v</span> <span class="op">=</span> <span class="number">42</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">x</span>, <span class="prelude-val">Some</span>(<span class="number">42</span>));</pre></div>
</div><h4 id='method.as_pin_ref' class="method"><code id='as_pin_ref.v'>pub fn <a href='#method.as_pin_ref' class='fnname'>as_pin_ref</a>(self: <a class="struct" href="https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;&amp;<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;&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="struct" href="https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;</a>T&gt;&gt;</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/core/option.rs.html#303-305' title='goto source code'>[src]</a></h4><div class='docblock'><p>Converts from <a href="../pin/struct.Pin.html"><code>Pin</code></a><code>&lt;&amp;Option&lt;T&gt;&gt;</code> to <code>Option&lt;</code><a href="../pin/struct.Pin.html"><code>Pin</code></a><code>&lt;&amp;T&gt;&gt;</code>.</p>
</div><h4 id='method.as_pin_mut' class="method"><code id='as_pin_mut.v'>pub fn <a href='#method.as_pin_mut' class='fnname'>as_pin_mut</a>(self: <a class="struct" href="https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;&amp;mut <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;&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="struct" href="https://doc.rust-lang.org/nightly/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T&gt;&gt;</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/core/option.rs.html#312-314' title='goto source code'>[src]</a></h4><div class='docblock'><p>Converts from <a href="../pin/struct.Pin.html"><code>Pin</code></a><code>&lt;&amp;mut Option&lt;T&gt;&gt;</code> to <code>Option&lt;</code><a href="../pin/struct.Pin.html"><code>Pin</code></a><code>&lt;&amp;mut T&gt;&gt;</code>.</p>
</div><h4 id='method.expect' class="method"><code id='expect.v'>pub fn <a href='#method.expect' class='fnname'>expect</a>(self, msg: &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#344-349' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the contained <a href="#variant.Some"><code>Some</code></a> value, consuming the <code>self</code> value.</p>
<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
<p>Panics if the value is a <a href="#variant.None"><code>None</code></a> with a custom panic message provided by
<code>msg</code>.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;value&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">expect</span>(<span class="string">&quot;fruits are healthy&quot;</span>), <span class="string">&quot;value&quot;</span>);</pre></div>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="ident">x</span>.<span class="ident">expect</span>(<span class="string">&quot;fruits are healthy&quot;</span>); <span class="comment">// panics with `fruits are healthy`</span></pre></div>
</div><h4 id='method.unwrap' class="method"><code id='unwrap.v'>pub fn <a href='#method.unwrap' class='fnname'>unwrap</a>(self) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#383-388' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the contained <a href="#variant.Some"><code>Some</code></a> value, consuming the <code>self</code> value.</p>
<p>Because this function may panic, its use is generally discouraged.
Instead, prefer to use pattern matching and handle the <a href="#variant.None"><code>None</code></a>
case explicitly, or call <a href="#method.unwrap_or"><code>unwrap_or</code></a>, <a href="#method.unwrap_or_else"><code>unwrap_or_else</code></a>, or
<a href="#method.unwrap_or_default"><code>unwrap_or_default</code></a>.</p>
<h1 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h1>
<p>Panics if the self value equals <a href="#variant.None"><code>None</code></a>.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;air&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">unwrap</span>(), <span class="string">&quot;air&quot;</span>);</pre></div>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">unwrap</span>(), <span class="string">&quot;air&quot;</span>); <span class="comment">// fails</span></pre></div>
</div><h4 id='method.unwrap_or' class="method"><code id='unwrap_or.v'>pub fn <a href='#method.unwrap_or' class='fnname'>unwrap_or</a>(self, default: T) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#407-412' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the contained <a href="#variant.Some"><code>Some</code></a> value or a provided default.</p>
<p>Arguments passed to <code>unwrap_or</code> are eagerly evaluated; if you are passing
the result of a function call, it is recommended to use <a href="#method.unwrap_or_else"><code>unwrap_or_else</code></a>,
which is lazily evaluated.</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="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="string">&quot;car&quot;</span>).<span class="ident">unwrap_or</span>(<span class="string">&quot;bike&quot;</span>), <span class="string">&quot;car&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">None</span>.<span class="ident">unwrap_or</span>(<span class="string">&quot;bike&quot;</span>), <span class="string">&quot;bike&quot;</span>);</pre></div>
</div><h4 id='method.unwrap_or_else' class="method"><code id='unwrap_or_else.v'>pub fn <a href='#method.unwrap_or_else' class='fnname'>unwrap_or_else</a>&lt;F&gt;(self, f: F) -&gt; T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</a>() -&gt; T,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#425-430' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the contained [<code>Some</code>] value or computes it from a closure.</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="kw">let</span> <span class="ident">k</span> <span class="op">=</span> <span class="number">10</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="number">4</span>).<span class="ident">unwrap_or_else</span>(<span class="op">|</span><span class="op">|</span> <span class="number">2</span> <span class="op">*</span> <span class="ident">k</span>), <span class="number">4</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">None</span>.<span class="ident">unwrap_or_else</span>(<span class="op">|</span><span class="op">|</span> <span class="number">2</span> <span class="op">*</span> <span class="ident">k</span>), <span class="number">20</span>);</pre></div>
</div><h4 id='method.map' class="method"><code id='map.v'>pub fn <a href='#method.map' class='fnname'>map</a>&lt;U, F&gt;(self, f: F) -&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;U&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</a>(T) -&gt; U,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#454-459' title='goto source code'>[src]</a></h4><div class='docblock'><p>Maps an <code>Option&lt;T&gt;</code> to <code>Option&lt;U&gt;</code> by applying a function to a contained value.</p>
<h1 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h1>
<p>Converts an <code>Option&lt;</code><a href="../../std/string/struct.String.html"><code>String</code></a><code>&gt;</code> into an <code>Option&lt;</code><a href="../../std/primitive.usize.html"><code>usize</code></a><code>&gt;</code>, consuming the original:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">maybe_some_string</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">String</span>::<span class="ident">from</span>(<span class="string">&quot;Hello, World!&quot;</span>));
<span class="comment">// `Option::map` takes self *by value*, consuming `maybe_some_string`</span>
<span class="kw">let</span> <span class="ident">maybe_some_len</span> <span class="op">=</span> <span class="ident">maybe_some_string</span>.<span class="ident">map</span>(<span class="op">|</span><span class="ident">s</span><span class="op">|</span> <span class="ident">s</span>.<span class="ident">len</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">maybe_some_len</span>, <span class="prelude-val">Some</span>(<span class="number">13</span>));</pre></div>
</div><h4 id='method.map_or' class="method"><code id='map_or.v'>pub fn <a href='#method.map_or' class='fnname'>map_or</a>&lt;U, F&gt;(self, default: U, f: F) -&gt; U <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</a>(T) -&gt; U,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#481-486' title='goto source code'>[src]</a></h4><div class='docblock'><p>Applies a function to the contained value (if any),
or returns the provided default (if not).</p>
<p>Arguments passed to <code>map_or</code> are eagerly evaluated; if you are passing
the result of a function call, it is recommended to use <a href="#method.map_or_else"><code>map_or_else</code></a>,
which is lazily evaluated.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;foo&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">map_or</span>(<span class="number">42</span>, <span class="op">|</span><span class="ident">v</span><span class="op">|</span> <span class="ident">v</span>.<span class="ident">len</span>()), <span class="number">3</span>);
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">map_or</span>(<span class="number">42</span>, <span class="op">|</span><span class="ident">v</span><span class="op">|</span> <span class="ident">v</span>.<span class="ident">len</span>()), <span class="number">42</span>);</pre></div>
</div><h4 id='method.map_or_else' class="method"><code id='map_or_else.v'>pub fn <a href='#method.map_or_else' class='fnname'>map_or_else</a>&lt;U, D, F&gt;(self, default: D, f: F) -&gt; U <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;D: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</a>() -&gt; U,<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</a>(T) -&gt; U,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#504-509' title='goto source code'>[src]</a></h4><div class='docblock'><p>Applies a function to the contained value (if any),
or computes a default (if not).</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="kw">let</span> <span class="ident">k</span> <span class="op">=</span> <span class="number">21</span>;
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;foo&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">map_or_else</span>(<span class="op">|</span><span class="op">|</span> <span class="number">2</span> <span class="op">*</span> <span class="ident">k</span>, <span class="op">|</span><span class="ident">v</span><span class="op">|</span> <span class="ident">v</span>.<span class="ident">len</span>()), <span class="number">3</span>);
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">map_or_else</span>(<span class="op">|</span><span class="op">|</span> <span class="number">2</span> <span class="op">*</span> <span class="ident">k</span>, <span class="op">|</span><span class="ident">v</span><span class="op">|</span> <span class="ident">v</span>.<span class="ident">len</span>()), <span class="number">42</span>);</pre></div>
</div><h4 id='method.ok_or' class="method"><code id='ok_or.v'>pub fn <a href='#method.ok_or' class='fnname'>ok_or</a>&lt;E&gt;(self, err: E) -&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, E&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#536-541' title='goto source code'>[src]</a></h4><div class='docblock'><p>Transforms the <code>Option&lt;T&gt;</code> into a <a href="../../std/result/enum.Result.html"><code>Result&lt;T, E&gt;</code></a>, mapping <a href="#variant.Some"><code>Some(v)</code></a> to
<a href="../../std/result/enum.Result.html#variant.Ok"><code>Ok(v)</code></a> and <a href="#variant.None"><code>None</code></a> to <a href="../../std/result/enum.Result.html#variant.Err"><code>Err(err)</code></a>.</p>
<p>Arguments passed to <code>ok_or</code> are eagerly evaluated; if you are passing the
result of a function call, it is recommended to use <a href="#method.ok_or_else"><code>ok_or_else</code></a>, which is
lazily evaluated.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;foo&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">ok_or</span>(<span class="number">0</span>), <span class="prelude-val">Ok</span>(<span class="string">&quot;foo&quot;</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">ok_or</span>(<span class="number">0</span>), <span class="prelude-val">Err</span>(<span class="number">0</span>));</pre></div>
</div><h4 id='method.ok_or_else' class="method"><code id='ok_or_else.v'>pub fn <a href='#method.ok_or_else' class='fnname'>ok_or_else</a>&lt;E, F&gt;(self, err: F) -&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, E&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</a>() -&gt; E,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#563-568' title='goto source code'>[src]</a></h4><div class='docblock'><p>Transforms the <code>Option&lt;T&gt;</code> into a <a href="../../std/result/enum.Result.html"><code>Result&lt;T, E&gt;</code></a>, mapping <a href="#variant.Some"><code>Some(v)</code></a> to
<a href="../../std/result/enum.Result.html#variant.Ok"><code>Ok(v)</code></a> and <a href="#variant.None"><code>None</code></a> to <a href="../../std/result/enum.Result.html#variant.Err"><code>Err(err())</code></a>.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;foo&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">ok_or_else</span>(<span class="op">|</span><span class="op">|</span> <span class="number">0</span>), <span class="prelude-val">Ok</span>(<span class="string">&quot;foo&quot;</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">ok_or_else</span>(<span class="op">|</span><span class="op">|</span> <span class="number">0</span>), <span class="prelude-val">Err</span>(<span class="number">0</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/option/struct.Iter.html" title="struct nom::lib::std::option::Iter">Iter</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#587-589' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns an iterator over the possibly contained value.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">4</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">iter</span>().<span class="ident">next</span>(), <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">4</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">iter</span>().<span class="ident">next</span>(), <span class="prelude-val">None</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/option/struct.IterMut.html" title="struct nom::lib::std::option::IterMut">IterMut</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#608-610' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns a mutable iterator over the possibly contained value.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">4</span>);
<span class="kw">match</span> <span class="ident">x</span>.<span class="ident">iter_mut</span>().<span class="ident">next</span>() {
<span class="prelude-val">Some</span>(<span class="ident">v</span>) <span class="op">=</span><span class="op">&gt;</span> <span class="kw-2">*</span><span class="ident">v</span> <span class="op">=</span> <span class="number">42</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">x</span>, <span class="prelude-val">Some</span>(<span class="number">42</span>));
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">iter_mut</span>().<span class="ident">next</span>(), <span class="prelude-val">None</span>);</pre></div>
</div><h4 id='method.and' class="method"><code id='and.v'>pub fn <a href='#method.and' class='fnname'>and</a>&lt;U&gt;(self, optb: <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;U&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;U&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#641-646' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <a href="#variant.None"><code>None</code></a> if the option is <a href="#variant.None"><code>None</code></a>, otherwise returns <code>optb</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">let</span> <span class="ident">y</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">and</span>(<span class="ident">y</span>), <span class="prelude-val">None</span>);
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;foo&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">and</span>(<span class="ident">y</span>), <span class="prelude-val">None</span>);
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;foo&quot;</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">and</span>(<span class="ident">y</span>), <span class="prelude-val">Some</span>(<span class="string">&quot;foo&quot;</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">y</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">and</span>(<span class="ident">y</span>), <span class="prelude-val">None</span>);</pre></div>
</div><h4 id='method.and_then' class="method"><code id='and_then.v'>pub fn <a href='#method.and_then' class='fnname'>and_then</a>&lt;U, F&gt;(self, f: F) -&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;U&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</a>(T) -&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;U&gt;,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#668-673' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <a href="#variant.None"><code>None</code></a> if the option is <a href="#variant.None"><code>None</code></a>, otherwise calls <code>f</code> with the
wrapped value and returns the result.</p>
<p>Some languages call this operation flatmap.</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">fn</span> <span class="ident">sq</span>(<span class="ident">x</span>: <span class="ident">u32</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> { <span class="prelude-val">Some</span>(<span class="ident">x</span> <span class="op">*</span> <span class="ident">x</span>) }
<span class="kw">fn</span> <span class="ident">nope</span>(<span class="kw">_</span>: <span class="ident">u32</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> { <span class="prelude-val">None</span> }
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="number">2</span>).<span class="ident">and_then</span>(<span class="ident">sq</span>).<span class="ident">and_then</span>(<span class="ident">sq</span>), <span class="prelude-val">Some</span>(<span class="number">16</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="number">2</span>).<span class="ident">and_then</span>(<span class="ident">sq</span>).<span class="ident">and_then</span>(<span class="ident">nope</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="number">2</span>).<span class="ident">and_then</span>(<span class="ident">nope</span>).<span class="ident">and_then</span>(<span class="ident">sq</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">None</span>.<span class="ident">and_then</span>(<span class="ident">sq</span>).<span class="ident">and_then</span>(<span class="ident">sq</span>), <span class="prelude-val">None</span>);</pre></div>
</div><h4 id='method.filter' class="method"><code id='filter.v'>pub fn <a href='#method.filter' class='fnname'>filter</a>&lt;P&gt;(self, predicate: P) -&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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;P: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</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.27.0'>1.27.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#703-710' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <a href="#variant.None"><code>None</code></a> if the option is <a href="#variant.None"><code>None</code></a>, otherwise calls <code>predicate</code>
with the wrapped value and returns:</p>
<ul>
<li><a href="#variant.Some"><code>Some(t)</code></a> if <code>predicate</code> returns <code>true</code> (where <code>t</code> is the wrapped
value), and</li>
<li><a href="#variant.None"><code>None</code></a> if <code>predicate</code> returns <code>false</code>.</li>
</ul>
<p>This function works similar to <a href="../../std/iter/trait.Iterator.html#method.filter"><code>Iterator::filter()</code></a>. You can imagine
the <code>Option&lt;T&gt;</code> being an iterator over one or zero elements. <code>filter()</code>
lets you decide which elements to keep.</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">fn</span> <span class="ident">is_even</span>(<span class="ident">n</span>: <span class="kw-2">&amp;</span><span class="ident">i32</span>) <span class="op">-</span><span class="op">&gt;</span> <span class="ident">bool</span> {
<span class="ident">n</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="prelude-val">None</span>.<span class="ident">filter</span>(<span class="ident">is_even</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="number">3</span>).<span class="ident">filter</span>(<span class="ident">is_even</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="number">4</span>).<span class="ident">filter</span>(<span class="ident">is_even</span>), <span class="prelude-val">Some</span>(<span class="number">4</span>));</pre></div>
</div><h4 id='method.or' class="method"><code id='or.v'>pub fn <a href='#method.or' class='fnname'>or</a>(self, optb: <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;) -&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/core/option.rs.html#741-746' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the option if it contains a value, otherwise returns <code>optb</code>.</p>
<p>Arguments passed to <code>or</code> are eagerly evaluated; if you are passing the
result of a function call, it is recommended to use <a href="#method.or_else"><code>or_else</code></a>, which is
lazily evaluated.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">or</span>(<span class="ident">y</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>));
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">100</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">or</span>(<span class="ident">y</span>), <span class="prelude-val">Some</span>(<span class="number">100</span>));
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">100</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">or</span>(<span class="ident">y</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">or</span>(<span class="ident">y</span>), <span class="prelude-val">None</span>);</pre></div>
</div><h4 id='method.or_else' class="method"><code id='or_else.v'>pub fn <a href='#method.or_else' class='fnname'>or_else</a>&lt;F&gt;(self, f: F) -&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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</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;,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#763-768' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the option if it contains a value, otherwise calls <code>f</code> and
returns the result.</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">fn</span> <span class="ident">nobody</span>() <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="lifetime">&#39;static</span> <span class="ident">str</span><span class="op">&gt;</span> { <span class="prelude-val">None</span> }
<span class="kw">fn</span> <span class="ident">vikings</span>() <span class="op">-</span><span class="op">&gt;</span> <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="lifetime">&#39;static</span> <span class="ident">str</span><span class="op">&gt;</span> { <span class="prelude-val">Some</span>(<span class="string">&quot;vikings&quot;</span>) }
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="string">&quot;barbarians&quot;</span>).<span class="ident">or_else</span>(<span class="ident">vikings</span>), <span class="prelude-val">Some</span>(<span class="string">&quot;barbarians&quot;</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">None</span>.<span class="ident">or_else</span>(<span class="ident">vikings</span>), <span class="prelude-val">Some</span>(<span class="string">&quot;vikings&quot;</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">None</span>.<span class="ident">or_else</span>(<span class="ident">nobody</span>), <span class="prelude-val">None</span>);</pre></div>
</div><h4 id='method.xor' class="method"><code id='xor.v'>pub fn <a href='#method.xor' class='fnname'>xor</a>(self, optb: <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;) -&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.37.0'>1.37.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#796-802' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns <a href="#variant.Some"><code>Some</code></a> if exactly one of <code>self</code>, <code>optb</code> is <a href="#variant.Some"><code>Some</code></a>, otherwise returns <a href="#variant.None"><code>None</code></a>.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">let</span> <span class="ident">y</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">xor</span>(<span class="ident">y</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</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">x</span>.<span class="ident">xor</span>(<span class="ident">y</span>), <span class="prelude-val">Some</span>(<span class="number">2</span>));
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</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">x</span>.<span class="ident">xor</span>(<span class="ident">y</span>), <span class="prelude-val">None</span>);
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">y</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">xor</span>(<span class="ident">y</span>), <span class="prelude-val">None</span>);</pre></div>
</div><h4 id='method.get_or_insert' class="method"><code id='get_or_insert.v'>pub fn <a href='#method.get_or_insert' class='fnname'>get_or_insert</a>(&amp;mut self, v: T) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T</code><span class='since' title='Stable since Rust version 1.20.0'>1.20.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#829-831' title='goto source code'>[src]</a></h4><div class='docblock'><p>Inserts <code>v</code> into the option if it is <a href="#variant.None"><code>None</code></a>, then
returns a mutable reference to the contained value.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">None</span>;
{
<span class="kw">let</span> <span class="ident">y</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">u32</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">get_or_insert</span>(<span class="number">5</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">y</span>, <span class="kw-2">&amp;</span><span class="number">5</span>);
<span class="kw-2">*</span><span class="ident">y</span> <span class="op">=</span> <span class="number">7</span>;
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">7</span>));</pre></div>
</div><h4 id='method.get_or_insert_with' class="method"><code id='get_or_insert_with.v'>pub fn <a href='#method.get_or_insert_with' class='fnname'>get_or_insert_with</a>&lt;F&gt;(&amp;mut self, f: F) -&gt; <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.reference.html">&amp;mut </a>T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;F: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.FnOnce.html" title="trait nom::lib::std::prelude::v1::v1::FnOnce">FnOnce</a>() -&gt; T,&nbsp;</span></code><span class='since' title='Stable since Rust version 1.20.0'>1.20.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#854-863' title='goto source code'>[src]</a></h4><div class='docblock'><p>Inserts a value computed from <code>f</code> into the option if it is <a href="#variant.None"><code>None</code></a>, then
returns a mutable reference to the contained value.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">None</span>;
{
<span class="kw">let</span> <span class="ident">y</span>: <span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">u32</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">get_or_insert_with</span>(<span class="op">|</span><span class="op">|</span> <span class="number">5</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">y</span>, <span class="kw-2">&amp;</span><span class="number">5</span>);
<span class="kw-2">*</span><span class="ident">y</span> <span class="op">=</span> <span class="number">7</span>;
}
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">7</span>));</pre></div>
</div><h4 id='method.take' class="method"><code id='take.v'>pub fn <a href='#method.take' class='fnname'>take</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/core/option.rs.html#888-890' title='goto source code'>[src]</a></h4><div class='docblock'><p>Takes the value out of the option, leaving a <a href="#variant.None"><code>None</code></a> in its place.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">take</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>, <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">y</span>, <span class="prelude-val">Some</span>(<span class="number">2</span>));
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">take</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>, <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">y</span>, <span class="prelude-val">None</span>);</pre></div>
</div><h4 id='method.replace' class="method"><code id='replace.v'>pub fn <a href='#method.replace' class='fnname'>replace</a>(&amp;mut self, value: T) -&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.31.0'>1.31.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#913-915' title='goto source code'>[src]</a></h4><div class='docblock'><p>Replaces the actual value in the option by the value given in parameter,
returning the old value if present,
leaving a <a href="#variant.Some"><code>Some</code></a> in its place without deinitializing either one.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="kw">let</span> <span class="ident">old</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">replace</span>(<span class="number">5</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">5</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">old</span>, <span class="prelude-val">Some</span>(<span class="number">2</span>));
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">old</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">replace</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</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">old</span>, <span class="prelude-val">None</span>);</pre></div>
</div></div><h3 id='impl-1' class='impl'><code class='in-band'>impl&lt;'_, T&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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <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-1' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#918-935' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.copied' class="method"><code id='copied.v'>pub fn <a href='#method.copied' class='fnname'>copied</a>(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><span class='since' title='Stable since Rust version 1.35.0'>1.35.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#932-934' title='goto source code'>[src]</a></h4><div class='docblock'><p>Maps an <code>Option&lt;&amp;T&gt;</code> to an <code>Option&lt;T&gt;</code> by copying the contents of the
option.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="number">12</span>;
<span class="kw">let</span> <span class="ident">opt_x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="ident">x</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">opt_x</span>, <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">12</span>));
<span class="kw">let</span> <span class="ident">copied</span> <span class="op">=</span> <span class="ident">opt_x</span>.<span class="ident">copied</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">copied</span>, <span class="prelude-val">Some</span>(<span class="number">12</span>));</pre></div>
</div></div><h3 id='impl-2' class='impl'><code class='in-band'>impl&lt;'_, T&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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <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-2' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#937-954' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.copied-1' class="method"><code id='copied.v-1'>pub fn <a href='#method.copied-1' class='fnname'>copied</a>(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><span class='since' title='Stable since Rust version 1.35.0'>1.35.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#951-953' title='goto source code'>[src]</a></h4><div class='docblock'><p>Maps an <code>Option&lt;&amp;mut T&gt;</code> to an <code>Option&lt;T&gt;</code> by copying the contents of the
option.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="number">12</span>;
<span class="kw">let</span> <span class="ident">opt_x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">x</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">opt_x</span>, <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="number">12</span>));
<span class="kw">let</span> <span class="ident">copied</span> <span class="op">=</span> <span class="ident">opt_x</span>.<span class="ident">copied</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">copied</span>, <span class="prelude-val">Some</span>(<span class="number">12</span>));</pre></div>
</div></div><h3 id='impl-3' class='impl'><code class='in-band'>impl&lt;'_, T&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; <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-3' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#956-973' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.cloned' class="method"><code id='cloned.v'>pub fn <a href='#method.cloned' class='fnname'>cloned</a>(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/core/option.rs.html#970-972' title='goto source code'>[src]</a></h4><div class='docblock'><p>Maps an <code>Option&lt;&amp;T&gt;</code> to an <code>Option&lt;T&gt;</code> by cloning the contents of the
option.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="number">12</span>;
<span class="kw">let</span> <span class="ident">opt_x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="ident">x</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">opt_x</span>, <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="number">12</span>));
<span class="kw">let</span> <span class="ident">cloned</span> <span class="op">=</span> <span class="ident">opt_x</span>.<span class="ident">cloned</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">cloned</span>, <span class="prelude-val">Some</span>(<span class="number">12</span>));</pre></div>
</div></div><h3 id='impl-4' class='impl'><code class='in-band'>impl&lt;'_, T&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; <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-4' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#975-992' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.cloned-1' class="method"><code id='cloned.v-1'>pub fn <a href='#method.cloned-1' class='fnname'>cloned</a>(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><span class='since' title='Stable since Rust version 1.26.0'>1.26.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#989-991' title='goto source code'>[src]</a></h4><div class='docblock'><p>Maps an <code>Option&lt;&amp;mut T&gt;</code> to an <code>Option&lt;T&gt;</code> by cloning the contents of the
option.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="number">12</span>;
<span class="kw">let</span> <span class="ident">opt_x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="ident">x</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">opt_x</span>, <span class="prelude-val">Some</span>(<span class="kw-2">&amp;</span><span class="kw-2">mut</span> <span class="number">12</span>));
<span class="kw">let</span> <span class="ident">cloned</span> <span class="op">=</span> <span class="ident">opt_x</span>.<span class="ident">cloned</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">cloned</span>, <span class="prelude-val">Some</span>(<span class="number">12</span>));</pre></div>
</div></div><h3 id='impl-5' class='impl'><code class='in-band'>impl&lt;T&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; <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-5' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#994-1080' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.expect_none' class="method"><code id='expect_none.v'>pub fn <a href='#method.expect_none' class='fnname'>expect_none</a>(self, msg: &amp;<a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.str.html">str</a>)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1032-1036' 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>option_expect_none</code>)</summary><p>newly added</p>
</details></div></div><div class='docblock'><p>Consumes <code>self</code> while expecting <a href="#variant.None"><code>None</code></a> and returning nothing.</p>
<h1 id="panics-2" class="section-header"><a href="#panics-2">Panics</a></h1>
<p>Panics if the value is a <a href="#variant.Some"><code>Some</code></a>, with a panic message including the
passed message, and the content of the <a href="#variant.Some"><code>Some</code></a>.</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="attribute">#![<span class="ident">feature</span>(<span class="ident">option_expect_none</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">HashMap</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">squares</span> <span class="op">=</span> <span class="ident">HashMap</span>::<span class="ident">new</span>();
<span class="kw">for</span> <span class="ident">i</span> <span class="kw">in</span> <span class="op">-</span><span class="number">10</span>..<span class="op">=</span><span class="number">10</span> {
<span class="comment">// This will not panic, since all keys are unique.</span>
<span class="ident">squares</span>.<span class="ident">insert</span>(<span class="ident">i</span>, <span class="ident">i</span> <span class="op">*</span> <span class="ident">i</span>).<span class="ident">expect_none</span>(<span class="string">&quot;duplicate key&quot;</span>);
}</pre></div>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">option_expect_none</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">HashMap</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sqrts</span> <span class="op">=</span> <span class="ident">HashMap</span>::<span class="ident">new</span>();
<span class="kw">for</span> <span class="ident">i</span> <span class="kw">in</span> <span class="op">-</span><span class="number">10</span>..<span class="op">=</span><span class="number">10</span> {
<span class="comment">// This will panic, since both negative and positive `i` will</span>
<span class="comment">// insert the same `i * i` key, returning the old `Some(i)`.</span>
<span class="ident">sqrts</span>.<span class="ident">insert</span>(<span class="ident">i</span> <span class="op">*</span> <span class="ident">i</span>, <span class="ident">i</span>).<span class="ident">expect_none</span>(<span class="string">&quot;duplicate key&quot;</span>);
}</pre></div>
</div><h4 id='method.unwrap_none' class="method"><code id='unwrap_none.v'>pub fn <a href='#method.unwrap_none' class='fnname'>unwrap_none</a>(self)</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1075-1079' 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>option_unwrap_none</code>)</summary><p>newly added</p>
</details></div></div><div class='docblock'><p>Consumes <code>self</code> while expecting <a href="#variant.None"><code>None</code></a> and returning nothing.</p>
<h1 id="panics-3" class="section-header"><a href="#panics-3">Panics</a></h1>
<p>Panics if the value is a [<code>Some</code>], with a custom panic message provided
by the [<code>Some</code>]'s value.</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="attribute">#![<span class="ident">feature</span>(<span class="ident">option_unwrap_none</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">HashMap</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">squares</span> <span class="op">=</span> <span class="ident">HashMap</span>::<span class="ident">new</span>();
<span class="kw">for</span> <span class="ident">i</span> <span class="kw">in</span> <span class="op">-</span><span class="number">10</span>..<span class="op">=</span><span class="number">10</span> {
<span class="comment">// This will not panic, since all keys are unique.</span>
<span class="ident">squares</span>.<span class="ident">insert</span>(<span class="ident">i</span>, <span class="ident">i</span> <span class="op">*</span> <span class="ident">i</span>).<span class="ident">unwrap_none</span>();
}</pre></div>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">option_unwrap_none</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">collections</span>::<span class="ident">HashMap</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sqrts</span> <span class="op">=</span> <span class="ident">HashMap</span>::<span class="ident">new</span>();
<span class="kw">for</span> <span class="ident">i</span> <span class="kw">in</span> <span class="op">-</span><span class="number">10</span>..<span class="op">=</span><span class="number">10</span> {
<span class="comment">// This will panic, since both negative and positive `i` will</span>
<span class="comment">// insert the same `i * i` key, returning the old `Some(i)`.</span>
<span class="ident">sqrts</span>.<span class="ident">insert</span>(<span class="ident">i</span> <span class="op">*</span> <span class="ident">i</span>, <span class="ident">i</span>).<span class="ident">unwrap_none</span>();
}</pre></div>
</div></div><h3 id='impl-6' class='impl'><code class='in-band'>impl&lt;T&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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Default.html" title="trait nom::lib::std::prelude::v1::v1::Default">Default</a>,&nbsp;</span></code><a href='#impl-6' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1082-1119' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.unwrap_or_default' class="method"><code id='unwrap_or_default.v'>pub fn <a href='#method.unwrap_or_default' class='fnname'>unwrap_or_default</a>(self) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1113-1118' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns the contained <a href="#variant.Some"><code>Some</code></a> value or a default</p>
<p>Consumes the <code>self</code> argument then, if <a href="#variant.Some"><code>Some</code></a>, returns the contained
value, otherwise if <a href="#variant.None"><code>None</code></a>, returns the <a href="../default/trait.Default.html#tymethod.default">default value</a> for that
type.</p>
<h1 id="examples-32" class="section-header"><a href="#examples-32">Examples</a></h1>
<p>Converts a string to an integer, turning poorly-formed strings
into 0 (the default value for integers). <a href="../../std/primitive.str.html#method.parse"><code>parse</code></a> converts
a string to any other type that implements <a href="../../std/str/trait.FromStr.html"><code>FromStr</code></a>, returning
<a href="#variant.None"><code>None</code></a> on error.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">good_year_from_input</span> <span class="op">=</span> <span class="string">&quot;1909&quot;</span>;
<span class="kw">let</span> <span class="ident">bad_year_from_input</span> <span class="op">=</span> <span class="string">&quot;190blarg&quot;</span>;
<span class="kw">let</span> <span class="ident">good_year</span> <span class="op">=</span> <span class="ident">good_year_from_input</span>.<span class="ident">parse</span>().<span class="ident">ok</span>().<span class="ident">unwrap_or_default</span>();
<span class="kw">let</span> <span class="ident">bad_year</span> <span class="op">=</span> <span class="ident">bad_year_from_input</span>.<span class="ident">parse</span>().<span class="ident">ok</span>().<span class="ident">unwrap_or_default</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">1909</span>, <span class="ident">good_year</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0</span>, <span class="ident">bad_year</span>);</pre></div>
</div></div><h3 id='impl-7' class='impl'><code class='in-band'>impl&lt;T&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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/ops/trait.Deref.html" title="trait nom::lib::std::ops::Deref">Deref</a>,&nbsp;</span></code><a href='#impl-7' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1121-1142' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.as_deref' class="method"><code id='as_deref.v'>pub fn <a href='#method.as_deref' class='fnname'>as_deref</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;&amp;&lt;T as <a class="trait" href="../../../../nom/lib/std/ops/trait.Deref.html" title="trait nom::lib::std::ops::Deref">Deref</a>&gt;::<a class="type" href="../../../../nom/lib/std/ops/trait.Deref.html#associatedtype.Target" title="type nom::lib::std::ops::Deref::Target">Target</a>&gt;</code><span class='since' title='Stable since Rust version 1.40.0'>1.40.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1139-1141' title='goto source code'>[src]</a></h4><div class='docblock'><p>Converts from <code>Option&lt;T&gt;</code> (or <code>&amp;Option&lt;T&gt;</code>) to <code>Option&lt;&amp;T::Target&gt;</code>.</p>
<p>Leaves the original Option in-place, creating a new one with a reference
to the original one, additionally coercing the contents via <a href="../../std/ops/trait.Deref.html"><code>Deref</code></a>.</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">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">String</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;hey&quot;</span>.<span class="ident">to_owned</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">as_deref</span>(), <span class="prelude-val">Some</span>(<span class="string">&quot;hey&quot;</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">String</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">as_deref</span>(), <span class="prelude-val">None</span>);</pre></div>
</div></div><h3 id='impl-8' class='impl'><code class='in-band'>impl&lt;T&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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/ops/trait.DerefMut.html" title="trait nom::lib::std::ops::DerefMut">DerefMut</a>,&nbsp;</span></code><a href='#impl-8' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1144-1163' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.as_deref_mut' class="method"><code id='as_deref_mut.v'>pub fn <a href='#method.as_deref_mut' class='fnname'>as_deref_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;&amp;mut &lt;T as <a class="trait" href="../../../../nom/lib/std/ops/trait.Deref.html" title="trait nom::lib::std::ops::Deref">Deref</a>&gt;::<a class="type" href="../../../../nom/lib/std/ops/trait.Deref.html#associatedtype.Target" title="type nom::lib::std::ops::Deref::Target">Target</a>&gt;</code><span class='since' title='Stable since Rust version 1.40.0'>1.40.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1160-1162' title='goto source code'>[src]</a></h4><div class='docblock'><p>Converts from <code>Option&lt;T&gt;</code> (or <code>&amp;mut Option&lt;T&gt;</code>) to <code>Option&lt;&amp;mut T::Target&gt;</code>.</p>
<p>Leaves the original <code>Option</code> in-place, creating a new one containing a mutable reference to
the inner type's <code>Deref::Target</code> type.</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">let</span> <span class="kw-2">mut</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">String</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;hey&quot;</span>.<span class="ident">to_owned</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">as_deref_mut</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> {
<span class="ident">x</span>.<span class="ident">make_ascii_uppercase</span>();
<span class="ident">x</span>
}), <span class="prelude-val">Some</span>(<span class="string">&quot;HEY&quot;</span>.<span class="ident">to_owned</span>().<span class="ident">as_mut_str</span>()));</pre></div>
</div></div><h3 id='impl-9' class='impl'><code class='in-band'>impl&lt;T, E&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/prelude/v1/v1/enum.Result.html" title="enum nom::lib::std::prelude::v1::v1::Result">Result</a>&lt;T, E&gt;&gt;</code><a href='#impl-9' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1165-1196' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.transpose' class="method"><code id='transpose.v'>pub fn <a href='#method.transpose' class='fnname'>transpose</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;<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;, E&gt;</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/core/option.rs.html#1189-1195' title='goto source code'>[src]</a></h4><div class='docblock'><p>Transposes an <code>Option</code> of a [<code>Result</code>] into a [<code>Result</code>] of an <code>Option</code>.</p>
<p><a href="#variant.None"><code>None</code></a> will be mapped to <a href="../../std/result/enum.Result.html#variant.Ok"><code>Ok</code></a><code>(</code><a href="#variant.None"><code>None</code></a><code>)</code>.
<a href="#variant.Some"><code>Some</code></a><code>(</code><a href="../../std/result/enum.Result.html#variant.Ok"><code>Ok</code></a><code>(_))</code> and <a href="#variant.Some"><code>Some</code></a><code>(</code><a href="../../std/result/enum.Result.html#variant.Err"><code>Err</code></a><code>(_))</code> will be mapped to
<a href="../../std/result/enum.Result.html#variant.Ok"><code>Ok</code></a><code>(</code><a href="#variant.Some"><code>Some</code></a><code>(_))</code> and <a href="../../std/result/enum.Result.html#variant.Err"><code>Err</code></a><code>(_)</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="attribute">#[<span class="ident">derive</span>(<span class="ident">Debug</span>, <span class="ident">Eq</span>, <span class="ident">PartialEq</span>)]</span>
<span class="kw">struct</span> <span class="ident">SomeErr</span>;
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Result</span><span class="op">&lt;</span><span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">i32</span><span class="op">&gt;</span>, <span class="ident">SomeErr</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">Ok</span>(<span class="prelude-val">Some</span>(<span class="number">5</span>));
<span class="kw">let</span> <span class="ident">y</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="prelude-ty">Result</span><span class="op">&lt;</span><span class="ident">i32</span>, <span class="ident">SomeErr</span><span class="op">&gt;</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Ok</span>(<span class="number">5</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>, <span class="ident">y</span>.<span class="ident">transpose</span>());</pre></div>
</div></div><h3 id='impl-10' class='impl'><code class='in-band'>impl&lt;T&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/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;T&gt;&gt;</code><a href='#impl-10' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1606-1632' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.flatten' class="method"><code id='flatten.v'>pub fn <a href='#method.flatten' class='fnname'>flatten</a>(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><span class='since' title='Stable since Rust version 1.40.0'>1.40.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1629-1631' title='goto source code'>[src]</a></h4><div class='docblock'><p>Converts from <code>Option&lt;Option&lt;T&gt;&gt;</code> to <code>Option&lt;T&gt;</code></p>
<h1 id="examples-36" class="section-header"><a href="#examples-36">Examples</a></h1>
<p>Basic usage:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Some</span>(<span class="number">6</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="number">6</span>), <span class="ident">x</span>.<span class="ident">flatten</span>());
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">None</span>, <span class="ident">x</span>.<span class="ident">flatten</span>());
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">None</span>, <span class="ident">x</span>.<span class="ident">flatten</span>());</pre></div>
<p>Flattening once only removes one level of nesting:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span><span class="op">&gt;</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="prelude-val">Some</span>(<span class="prelude-val">Some</span>(<span class="number">6</span>)));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="prelude-val">Some</span>(<span class="number">6</span>)), <span class="ident">x</span>.<span class="ident">flatten</span>());
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="number">6</span>), <span class="ident">x</span>.<span class="ident">flatten</span>().<span class="ident">flatten</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="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; <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/core/option.rs.html#1219-1235' 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="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/core/option.rs.html#1221-1226' 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, source: &amp;<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/core/option.rs.html#1229-1234' 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-Copy' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/prelude/v1/v1/trait.Copy.html" title="trait nom::lib::std::prelude::v1::v1::Copy">Copy</a> for <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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <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-Copy' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#153' title='goto source code'>[src]</a></h3><div class='impl-items'></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="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; <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/core/option.rs.html#153' 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/core/option.rs.html#153' 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="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 href='#impl-Default' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1238-1251' 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="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/core/option.rs.html#1248-1250' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns [<code>None</code>][Option::None].</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">let</span> <span class="ident">opt</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">u32</span><span class="op">&gt;</span> <span class="op">=</span> <span class="prelude-ty">Option</span>::<span class="ident">default</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">opt</span>.<span class="ident">is_none</span>());</pre></div>
</div></div><h3 id='impl-Eq' class='impl'><code class='in-band'>impl&lt;T&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="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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <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/core/option.rs.html#153' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-From%3C%26%27a%20Option%3CT%3E%3E' class='impl'><code class='in-band'>impl&lt;'a, 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;&amp;'a <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;&gt; for <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 </a>T&gt;</code><a href='#impl-From%3C%26%27a%20Option%3CT%3E%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.30.0'>1.30.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1305-1309' 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>(o: &amp;'a <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;) -&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 </a>T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1306-1308' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3C%26%27a%20mut%20Option%3CT%3E%3E' class='impl'><code class='in-band'>impl&lt;'a, 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;&amp;'a mut <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;&gt; for <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 mut </a>T&gt;</code><a href='#impl-From%3C%26%27a%20mut%20Option%3CT%3E%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.30.0'>1.30.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1312-1316' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from-1' class="method hidden"><code id='from.v-1'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.From.html#tymethod.from' class='fnname'>from</a>(o: &amp;'a mut <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;) -&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 mut </a>T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1313-1315' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</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 <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 href='#impl-From%3CT%3E' class='anchor'></a><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/core/option.rs.html#1298-1302' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from' class="method hidden"><code id='from.v'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.From.html#tymethod.from' class='fnname'>from</a>(val: T) -&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/core/option.rs.html#1299-1301' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-FromIterator%3COption%3CA%3E%3E' class='impl'><code class='in-band'>impl&lt;A, V&gt; <a class="trait" href="../../../../nom/lib/std/iter/trait.FromIterator.html" title="trait nom::lib::std::iter::FromIterator">FromIterator</a>&lt;<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&gt;&gt; for <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;V&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;V: <a class="trait" href="../../../../nom/lib/std/iter/trait.FromIterator.html" title="trait nom::lib::std::iter::FromIterator">FromIterator</a>&lt;A&gt;,&nbsp;</span></code><a href='#impl-FromIterator%3COption%3CA%3E%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1505-1575' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from_iter' class="method"><code id='from_iter.v'>fn <a href='../../../../nom/lib/std/iter/trait.FromIterator.html#tymethod.from_iter' class='fnname'>from_iter</a>&lt;I&gt;(iter: I) -&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;V&gt; <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="enum" href="../../../../nom/lib/std/prelude/v1/v1/enum.Option.html" title="enum nom::lib::std::prelude::v1::v1::Option">Option</a>&lt;A&gt;&gt;,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1569-1574' title='goto source code'>[src]</a></h4><div class='docblock'><p>Takes each element in the <a href="../iter/trait.Iterator.html"><code>Iterator</code></a>: if it is [<code>None</code>][Option::None],
no further elements are taken, and the [<code>None</code>][Option::None] is
returned. Should no [<code>None</code>][Option::None] occur, a container with the
values of each [<code>Option</code>] is returned.</p>
<h1 id="examples-40" class="section-header"><a href="#examples-40">Examples</a></h1>
<p>Here is an example which increments every integer in a vector.
We use the checked variant of <code>add</code> that returns <code>None</code> when the
calculation would result in an overflow.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">items</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">0_u16</span>, <span class="number">1</span>, <span class="number">2</span>];
<span class="kw">let</span> <span class="ident">res</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">Vec</span><span class="op">&lt;</span><span class="ident">u16</span><span class="op">&gt;</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">items</span>
.<span class="ident">iter</span>()
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span>.<span class="ident">checked_add</span>(<span class="number">1</span>))
.<span class="ident">collect</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>, <span class="prelude-val">Some</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>]));</pre></div>
<p>As you can see, this will return the expected, valid items.</p>
<p>Here is another example that tries to subtract one from another list
of integers, this time checking for underflow:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">items</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">2_u16</span>, <span class="number">1</span>, <span class="number">0</span>];
<span class="kw">let</span> <span class="ident">res</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">Vec</span><span class="op">&lt;</span><span class="ident">u16</span><span class="op">&gt;</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">items</span>
.<span class="ident">iter</span>()
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span>.<span class="ident">checked_sub</span>(<span class="number">1</span>))
.<span class="ident">collect</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>, <span class="prelude-val">None</span>);</pre></div>
<p>Since the last element is zero, it would underflow. Thus, the resulting
value is <code>None</code>.</p>
<p>Here is a variation on the previous example, showing that no
further elements are taken from <code>iter</code> after the first <code>None</code>.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">items</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="number">3_u16</span>, <span class="number">2</span>, <span class="number">1</span>, <span class="number">10</span>];
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">shared</span> <span class="op">=</span> <span class="number">0</span>;
<span class="kw">let</span> <span class="ident">res</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">Vec</span><span class="op">&lt;</span><span class="ident">u16</span><span class="op">&gt;</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">items</span>
.<span class="ident">iter</span>()
.<span class="ident">map</span>(<span class="op">|</span><span class="ident">x</span><span class="op">|</span> { <span class="ident">shared</span> <span class="op">+</span><span class="op">=</span> <span class="ident">x</span>; <span class="ident">x</span>.<span class="ident">checked_sub</span>(<span class="number">2</span>) })
.<span class="ident">collect</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">res</span>, <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">shared</span>, <span class="number">6</span>);</pre></div>
<p>Since the third element caused an underflow, no further elements were taken,
so the final value of <code>shared</code> is 6 (= <code>3 + 2 + 1</code>), not 16.</p>
</div></div><h3 id='impl-Hash' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/hash/trait.Hash.html" title="trait nom::lib::std::hash::Hash">Hash</a> for <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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <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/core/option.rs.html#153' 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/core/option.rs.html#153' 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-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="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 href='#impl-IntoIterator' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1254-1275' 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/option/struct.IntoIter.html" title="struct nom::lib::std::option::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/option/struct.IntoIter.html" title="struct nom::lib::std::option::IntoIter">IntoIter</a>&lt;T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1272-1274' title='goto source code'>[src]</a></h4><div class='docblock'><p>Returns a consuming iterator over the possibly contained value.</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">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">&quot;string&quot;</span>);
<span class="kw">let</span> <span class="ident">v</span>: <span class="ident">Vec</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">into_iter</span>().<span class="ident">collect</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">v</span>, [<span class="string">&quot;string&quot;</span>]);
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">v</span>: <span class="ident">Vec</span><span class="op">&lt;</span><span class="kw-2">&amp;</span><span class="ident">str</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">x</span>.<span class="ident">into_iter</span>().<span class="ident">collect</span>();
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">v</span>.<span class="ident">is_empty</span>());</pre></div>
</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 mut <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 href='#impl-IntoIterator-1' class='anchor'></a><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/core/option.rs.html#1288-1295' 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 mut </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/option/struct.IterMut.html" title="struct nom::lib::std::option::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-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/option/struct.IterMut.html" title="struct nom::lib::std::option::IterMut">IterMut</a>&lt;'a, T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1292-1294' 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 <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 href='#impl-IntoIterator-2' class='anchor'></a><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/core/option.rs.html#1278-1285' 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 </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/option/struct.Iter.html" title="struct nom::lib::std::option::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-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/option/struct.Iter.html" title="struct nom::lib::std::option::Iter">Iter</a>&lt;'a, T&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1282-1284' 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;T&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="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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <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/core/option.rs.html#153' 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="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;) -&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/core/option.rs.html#153' 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%3COption%3CT%3E%3E' class='impl'><code class='in-band'>impl&lt;T&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="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;&gt; for <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; <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><a href='#impl-PartialEq%3COption%3CT%3E%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#153' 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;<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;) -&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/option.rs.html#153' 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'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&amp;self, other: &amp;<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;) -&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/option.rs.html#153' 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%3COption%3CT%3E%3E' class='impl'><code class='in-band'>impl&lt;T&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="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;&gt; for <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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <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;T&gt;,&nbsp;</span></code><a href='#impl-PartialOrd%3COption%3CT%3E%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#153' 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="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;) -&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/core/option.rs.html#153' 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'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.lt' class='fnname'>lt</a>(&amp;self, other: &amp;<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;) -&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/option.rs.html#153' 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'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.le' class='fnname'>le</a>(&amp;self, other: &amp;<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;) -&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/option.rs.html#153' 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'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.gt' class='fnname'>gt</a>(&amp;self, other: &amp;<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;) -&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/option.rs.html#153' 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'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.PartialOrd.html#method.ge' class='fnname'>ge</a>(&amp;self, other: &amp;<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;) -&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/option.rs.html#153' 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><h3 id='impl-Product%3COption%3CU%3E%3E' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="../../../../nom/lib/std/iter/trait.Product.html" title="trait nom::lib::std::iter::Product">Product</a>&lt;<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;U&gt;&gt; for <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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/iter/trait.Product.html" title="trait nom::lib::std::iter::Product">Product</a>&lt;U&gt;,&nbsp;</span></code><a href='#impl-Product%3COption%3CU%3E%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.37.0'>1.37.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/iter/traits/accum.rs.html#192-205' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.product' class="method"><code id='product.v'>fn <a href='../../../../nom/lib/std/iter/trait.Product.html#tymethod.product' class='fnname'>product</a>&lt;I&gt;(iter: I) -&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; <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>&lt;Item = <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;U&gt;&gt;,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/iter/traits/accum.rs.html#199-204' title='goto source code'>[src]</a></h4><div class='docblock'><p>Takes each element in the <code>Iterator</code>: if it is a <code>None</code>, no further
elements are taken, and the <code>None</code> is returned. Should no <code>None</code> occur,
the product of all elements is returned.</p>
</div></div><h3 id='impl-StructuralEq' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.StructuralEq.html" title="trait core::marker::StructuralEq">StructuralEq</a> for <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 href='#impl-StructuralEq' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#153' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-StructuralPartialEq' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/nightly/core/marker/trait.StructuralPartialEq.html" title="trait core::marker::StructuralPartialEq">StructuralPartialEq</a> for <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 href='#impl-StructuralPartialEq' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#153' title='goto source code'>[src]</a></h3><div class='impl-items'></div><h3 id='impl-Sum%3COption%3CU%3E%3E' class='impl'><code class='in-band'>impl&lt;T, U&gt; <a class="trait" href="../../../../nom/lib/std/iter/trait.Sum.html" title="trait nom::lib::std::iter::Sum">Sum</a>&lt;<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;U&gt;&gt; for <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; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="../../../../nom/lib/std/iter/trait.Sum.html" title="trait nom::lib::std::iter::Sum">Sum</a>&lt;U&gt;,&nbsp;</span></code><a href='#impl-Sum%3COption%3CU%3E%3E' class='anchor'></a><span class='since' title='Stable since Rust version 1.37.0'>1.37.0</span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/iter/traits/accum.rs.html#165-189' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.sum' class="method"><code id='sum.v'>fn <a href='../../../../nom/lib/std/iter/trait.Sum.html#tymethod.sum' class='fnname'>sum</a>&lt;I&gt;(iter: I) -&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; <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>&lt;Item = <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;U&gt;&gt;,&nbsp;</span></code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/iter/traits/accum.rs.html#183-188' title='goto source code'>[src]</a></h4><div class='docblock'><p>Takes each element in the <code>Iterator</code>: if it is a <code>None</code>, no further
elements are taken, and the <code>None</code> is returned. Should no <code>None</code> occur,
the sum of all elements is returned.</p>
<h1 id="examples-39" class="section-header"><a href="#examples-39">Examples</a></h1>
<p>This sums up the position of the character 'a' in a vector of strings,
if a word did not have the character 'a' the operation returns <code>None</code>:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">words</span> <span class="op">=</span> <span class="macro">vec</span><span class="macro">!</span>[<span class="string">&quot;have&quot;</span>, <span class="string">&quot;a&quot;</span>, <span class="string">&quot;great&quot;</span>, <span class="string">&quot;day&quot;</span>];
<span class="kw">let</span> <span class="ident">total</span>: <span class="prelude-ty">Option</span><span class="op">&lt;</span><span class="ident">usize</span><span class="op">&gt;</span> <span class="op">=</span> <span class="ident">words</span>.<span class="ident">iter</span>().<span class="ident">map</span>(<span class="op">|</span><span class="ident">w</span><span class="op">|</span> <span class="ident">w</span>.<span class="ident">find</span>(<span class="string">&#39;a&#39;</span>)).<span class="ident">sum</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">total</span>, <span class="prelude-val">Some</span>(<span class="number">5</span>));</pre></div>
</div></div><h3 id='impl-Try' class='impl'><code class='in-band'>impl&lt;T&gt; <a class="trait" href="../../../../nom/lib/std/ops/trait.Try.html" title="trait nom::lib::std::ops::Try">Try</a> for <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 href='#impl-Try' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1586-1604' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='associatedtype.Ok' class="type"><code id='Ok.t'>type <a href='../../../../nom/lib/std/ops/trait.Try.html#associatedtype.Ok' class="type">Ok</a> = T</code></h4><div class='stability'><div class='stab unstable'><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>try_trait</code>)</div></div><div class='docblock'><p>The type of this value when viewed as successful.</p>
</div><h4 id='associatedtype.Error' class="type"><code id='Error.t'>type <a href='../../../../nom/lib/std/ops/trait.Try.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../../../../nom/lib/std/option/struct.NoneError.html" title="struct nom::lib::std::option::NoneError">NoneError</a></code></h4><div class='stability'><div class='stab unstable'><span class='emoji'>🔬</span> This is a nightly-only experimental API. (<code>try_trait</code>)</div></div><div class='docblock'><p>The type of this value when viewed as failed.</p>
</div><h4 id='method.into_result' class="method hidden"><code id='into_result.v'>fn <a href='../../../../nom/lib/std/ops/trait.Try.html#tymethod.into_result' class='fnname'>into_result</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;T, <a class="struct" href="../../../../nom/lib/std/option/struct.NoneError.html" title="struct nom::lib::std::option::NoneError">NoneError</a>&gt;</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/option.rs.html#1591-1593' 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>try_trait</code>)</div></div><div class='docblock hidden'><p>Applies the &quot;?&quot; operator. A return of <code>Ok(t)</code> means that the execution should continue normally, and the result of <code>?</code> is the value <code>t</code>. A return of <code>Err(e)</code> means that execution should branch to the innermost enclosing <code>catch</code>, or return from the function. <a href="../../../../nom/lib/std/ops/trait.Try.html#tymethod.into_result">Read more</a></p>
</div><h4 id='method.from_ok' class="method hidden"><code id='from_ok.v'>fn <a href='../../../../nom/lib/std/ops/trait.Try.html#tymethod.from_ok' class='fnname'>from_ok</a>(v: T) -&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/core/option.rs.html#1596-1598' 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>try_trait</code>)</div></div><div class='docblock hidden'><p>Wrap an OK value to construct the composite result. For example, <code>Result::Ok(x)</code> and <code>Result::from_ok(x)</code> are equivalent. <a href="../../../../nom/lib/std/ops/trait.Try.html#tymethod.from_ok">Read more</a></p>
</div><h4 id='method.from_error' class="method hidden"><code id='from_error.v'>fn <a href='../../../../nom/lib/std/ops/trait.Try.html#tymethod.from_error' class='fnname'>from_error</a>(<a class="struct" href="../../../../nom/lib/std/option/struct.NoneError.html" title="struct nom::lib::std::option::NoneError">NoneError</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/core/option.rs.html#1601-1603' 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>try_trait</code>)</div></div><div class='docblock hidden'><p>Wrap an error value to construct the composite result. For example, <code>Result::Err(x)</code> and <code>Result::from_error(x)</code> are equivalent. <a href="../../../../nom/lib/std/ops/trait.Try.html#tymethod.from_error">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="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; <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="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; <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="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; <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="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; <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="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; <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%3C!%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="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.never.html">!</a>&gt; for T</code><a href='#impl-From%3C!%3E' class='anchor'></a><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#579-583' title='goto source code'>[src]</a></h3><div class='impl-items'><h4 id='method.from-3' class="method hidden"><code id='from.v-3'>fn <a href='../../../../nom/lib/std/prelude/v1/v1/trait.From.html#tymethod.from' class='fnname'>from</a>(t: <a class="primitive" href="https://doc.rust-lang.org/nightly/std/primitive.never.html">!</a>) -&gt; T</code><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/convert/mod.rs.html#580-582' title='goto source code'>[src]</a></h4><div class='docblock hidden'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3CT%3E-1' 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-1' 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-4' class="method hidden"><code id='from.v-4'>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-1' class="type"><code id='Error.t-1'>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-2' class="type"><code id='Error.t-2'>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