<!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="The `Option` type. See the module level documentation for more."><meta name="keywords" content="rust, rustlang, rust-lang, Option"><title>Option in enum_primitive - 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="../light.css" id="themeStyle"><link rel="stylesheet" type="text/css" href="../dark.css" disabled ><link rel="stylesheet" type="text/css" href="../ayu.css" disabled ><script id="default-settings"></script><script src="../storage.js"></script><script src="../crates.js"></script><noscript><link rel="stylesheet" href="../noscript.css"></noscript><link rel="icon" type="image/svg+xml" href="../favicon.svg">
<link rel="alternate icon" type="image/png" href="../favicon-16x16.png">
<link rel="alternate icon" type="image/png" href="../favicon-32x32.png"><style type="text/css">#crate-search{background-image:url("../down-arrow.svg");}</style></head><body class="rustdoc enum"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu" role="button">☰</div><a href='../enum_primitive/index.html'><div class='logo-container rust-logo'><img src='../rust-logo.png' alt='logo'></div></a><h2 class="location">Enum Option</h2><div class="sidebar-elems"><div class="block items"><h3 class="sidebar-title"><a href="#variants">Variants</a></h3><div class="sidebar-links"><a href="#variant.None">None</a><a href="#variant.Some">Some</a></div><h3 class="sidebar-title"><a href="#implementations">Methods</a></h3><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.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_default">get_or_insert_default</a><a href="#method.get_or_insert_with">get_or_insert_with</a><a href="#method.insert">insert</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_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.unwrap_unchecked">unwrap_unchecked</a><a href="#method.xor">xor</a><a href="#method.zip">zip</a><a href="#method.zip_with">zip_with</a></div><h3 class="sidebar-title"><a href="#trait-implementations">Trait Implementations</a></h3><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<&'a Option<T>></a><a href="#impl-From%3C%26%27a%20mut%20Option%3CT%3E%3E">From<&'a mut Option<T>></a><a href="#impl-From%3CT%3E">From<T></a><a href="#impl-FromIterator%3COption%3CA%3E%3E">FromIterator<Option<A>></a><a href="#impl-FromResidual%3C%3COption%3CT%3E%20as%20Try%3E%3A%3AResidual%3E">FromResidual<<Option<T> as Try>::Residual></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<Option<T>></a><a href="#impl-PartialOrd%3COption%3CT%3E%3E">PartialOrd<Option<T>></a><a href="#impl-Product%3COption%3CU%3E%3E">Product<Option<U>></a><a href="#impl-StructuralEq">StructuralEq</a><a href="#impl-StructuralPartialEq">StructuralPartialEq</a><a href="#impl-Sum%3COption%3CU%3E%3E">Sum<Option<U>></a><a href="#impl-Try">Try</a></div><h3 class="sidebar-title"><a href="#synthetic-implementations">Auto Trait Implementations</a></h3><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><h3 class="sidebar-title"><a href="#blanket-implementations">Blanket Implementations</a></h3><div class="sidebar-links"><a href="#impl-Any">Any</a><a href="#impl-Borrow%3CT%3E">Borrow<T></a><a href="#impl-BorrowMut%3CT%3E">BorrowMut<T></a><a href="#impl-From%3C!%3E">From<!></a><a href="#impl-From%3CT%3E">From<T></a><a href="#impl-Into%3CU%3E">Into<U></a><a href="#impl-ToOwned">ToOwned</a><a href="#impl-TryFrom%3CU%3E">TryFrom<U></a><a href="#impl-TryInto%3CU%3E">TryInto<U></a></div></div><h2 class="location">Other items in<br><a href="index.html">enum_primitive</a></h2><div id="sidebar-vars" data-name="Option" data-ty="enum" data-relpath=""></div><script defer src="sidebar-items.js"></script></div></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!" aria-haspopup="menu" title="themes"><img src="../brush.svg" width="18" height="18" alt="Pick another theme!"></button><div id="theme-choices" role="menu"></div></div><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><button type="button" id="help-button" title="help">?</button><a id="settings-menu" href="../settings.html" title="settings"><img src="../wheel.svg" width="18" height="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class="fqn"><span class="in-band">Enum <a href="index.html">enum_primitive</a>::<wbr><a class="enum" href="#">Option</a><button id="copy-path" onclick="copy_path(this)" title="copy path"><img src="../clipboard.svg" width="19" height="18" alt="Copy item import" title="Copy item import to clipboard"></button></span><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">−</span>]</a></span><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#163-172" title="goto source code">[src]</a></span></h1><div class="docblock type-decl"><pre class="rust enum">pub enum Option<T> {
None,
Some(T),
}</pre></div><details class="rustdoc-toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>The <code>Option</code> type. See <a href="https://doc.rust-lang.org/1.54.0/core/option/index.html">the module level documentation</a> for more.</p>
</div></details><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>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>Some(T)</code></div><div class="docblock"><p>Some value <code>T</code></p>
</div><h2 id="implementations" class="small-section-header">Implementations<a href="#implementations" class="anchor"></a></h2><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><a href="#impl" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#178-1052" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.is_some" class="method has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use = "if you intended to assert that this has a value, consider `.unwrap()` instead"]</div>pub const fn <a href="#method.is_some" class="fnname">is_some</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><span class="since" title="Stable since Rust version 1.0.0, const since 1.48.0">1.0.0 (const: 1.48.0)</span><a href="#method.is_some" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#198" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns <code>true</code> if the option is a <a href="enum.Option.html#variant.Some" title="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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="macro">assert_eq!</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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">is_some</span>(), <span class="bool-val">false</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.is_none" class="method has-srclink"><h4 class="code-header"><div class="code-attribute">#[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"]</div>pub const fn <a href="#method.is_none" class="fnname">is_none</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><span class="since" title="Stable since Rust version 1.0.0, const since 1.48.0">1.0.0 (const: 1.48.0)</span><a href="#method.is_none" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#218" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns <code>true</code> if the option is a <a href="enum.Option.html#variant.None" title="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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="macro">assert_eq!</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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">is_none</span>(), <span class="bool-val">true</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.contains" class="method has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>pub fn <a href="#method.contains" class="fnname">contains</a><U>(&self, x: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>U) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a> <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a><T>, </span></h4><a href="#method.contains" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#241-243" title="goto source code">[src]</a></div><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>option_result_contains</code>)</div></div></summary><div class="docblock"><p>Returns <code>true</code> if the option is a <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a> 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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">2</span>);
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">contains</span>(<span class="kw-2">&</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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">3</span>);
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">contains</span>(<span class="kw-2">&</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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">contains</span>(<span class="kw-2">&</span><span class="number">2</span>), <span class="bool-val">false</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_ref" class="method has-srclink"><h4 class="code-header">pub const fn <a href="#method.as_ref" class="fnname">as_ref</a>(&self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>T></h4><span class="since" title="Stable since Rust version 1.0.0, const since 1.48.0">1.0.0 (const: 1.48.0)</span><a href="#method.as_ref" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#277" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <code>&Option<T></code> to <code>Option<&T></code>.</p>
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
<p>Converts an <code>Option<</code><a href="../../std/string/struct.String.html"><code>String</code></a><code>></code> into an <code>Option<</code><a href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html" title="usize"><code>usize</code></a><code>></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"><</span><span class="ident">String</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">"Hello, world!"</span>.<span class="ident">to_string</span>());
<span class="comment">// First, cast `Option<String>` to `Option<&String>` 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"><</span><span class="ident">usize</span><span class="op">></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="string">"still can print text: {:?}"</span>, <span class="ident">text</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_mut" class="fnname">as_mut</a>(&mut self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T></h4><a href="#method.as_mut" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#298" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <code>&mut Option<T></code> to <code>Option<&mut T></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">></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">></span> {},
}
<span class="macro">assert_eq!</span>(<span class="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">42</span>));</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_pin_ref" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_pin_ref" class="fnname">as_pin_ref</a>(self: <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a><&<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="struct" href="https://doc.rust-lang.org/1.54.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>T>></h4><span class="since" title="Stable since Rust version 1.33.0">1.33.0</span><a href="#method.as_pin_ref" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#308" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <a href="https://doc.rust-lang.org/1.54.0/core/pin/struct.Pin.html" title="Pin"><code>Pin</code></a><code><&Option<T>></code> to <code>Option<</code><a href="https://doc.rust-lang.org/1.54.0/core/pin/struct.Pin.html" title="Pin"><code>Pin</code></a><code><&T>></code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_pin_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_pin_mut" class="fnname">as_pin_mut</a>(self: <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a><&mut <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="struct" href="https://doc.rust-lang.org/1.54.0/core/pin/struct.Pin.html" title="struct core::pin::Pin">Pin</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T>></h4><span class="since" title="Stable since Rust version 1.33.0">1.33.0</span><a href="#method.as_pin_mut" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#317" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <a href="https://doc.rust-lang.org/1.54.0/core/pin/struct.Pin.html" title="Pin"><code>Pin</code></a><code><&mut Option<T>></code> to <code>Option<</code><a href="https://doc.rust-lang.org/1.54.0/core/pin/struct.Pin.html" title="Pin"><code>Pin</code></a><code><&mut T>></code>.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.expect" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.expect" class="fnname">expect</a>(self, msg: &<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.str.html">str</a>) -> T</h4><a href="#method.expect" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#348" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns the contained <a href="enum.Option.html#variant.Some" title="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="enum.Option.html#variant.None" title="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">"value"</span>);
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">expect</span>(<span class="string">"fruits are healthy"</span>), <span class="string">"value"</span>);</pre></div>
<div class='information'><div class='tooltip should_panic'>ⓘ</div></div><div class="example-wrap"><pre class="rust rust-example-rendered should_panic">
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="ident">x</span>.<span class="ident">expect</span>(<span class="string">"fruits are healthy"</span>); <span class="comment">// panics with `fruits are healthy`</span></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.unwrap" class="method has-srclink"><h4 class="code-header">pub const fn <a href="#method.unwrap" class="fnname">unwrap</a>(self) -> T</h4><a href="#method.unwrap" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#385" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns the contained <a href="enum.Option.html#variant.Some" title="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="enum.Option.html#variant.None" title="None"><code>None</code></a>
case explicitly, or call <a href="enum.Option.html#method.unwrap_or"><code>unwrap_or</code></a>, <a href="enum.Option.html#method.unwrap_or_else"><code>unwrap_or_else</code></a>, or
<a href="enum.Option.html#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="enum.Option.html#variant.None" title="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">"air"</span>);
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">unwrap</span>(), <span class="string">"air"</span>);</pre></div>
<div class='information'><div class='tooltip should_panic'>ⓘ</div></div><div class="example-wrap"><pre class="rust rust-example-rendered should_panic">
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">unwrap</span>(), <span class="string">"air"</span>); <span class="comment">// fails</span></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.unwrap_or" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.unwrap_or" class="fnname">unwrap_or</a>(self, default: T) -> T</h4><a href="#method.unwrap_or" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#408" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns the contained <a href="enum.Option.html#variant.Some" title="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="enum.Option.html#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="prelude-val">Some</span>(<span class="string">"car"</span>).<span class="ident">unwrap_or</span>(<span class="string">"bike"</span>), <span class="string">"car"</span>);
<span class="macro">assert_eq!</span>(<span class="prelude-val">None</span>.<span class="ident">unwrap_or</span>(<span class="string">"bike"</span>), <span class="string">"bike"</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.unwrap_or_else" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.unwrap_or_else" class="fnname">unwrap_or_else</a><F>(self, f: F) -> T <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -> T, </span></h4><a href="#method.unwrap_or_else" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#426" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns the contained <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a> 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="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="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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.unwrap_unchecked" class="method has-srclink"><h4 class="code-header">pub unsafe fn <a href="#method.unwrap_unchecked" class="fnname">unwrap_unchecked</a>(self) -> T</h4><a href="#method.unwrap_unchecked" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#458" title="goto source code">[src]</a></div><div class="item-info"><div class="stab unstable"><details><summary><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>option_result_unwrap_unchecked</code>)</summary><p>newly added</p>
</details></div></div></summary><div class="docblock"><p>Returns the contained <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a> value, consuming the <code>self</code> value,
without checking that the value is not <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>.</p>
<h1 id="safety" class="section-header"><a href="#safety">Safety</a></h1>
<p>Calling this method on <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> is <em><a href="https://doc.rust-lang.org/reference/behavior-considered-undefined.html">undefined behavior</a></em>.</p>
<h1 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">option_result_unwrap_unchecked</span>)]</span>
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">"air"</span>);
<span class="macro">assert_eq!</span>(<span class="kw">unsafe</span> { <span class="ident">x</span>.<span class="ident">unwrap_unchecked</span>() }, <span class="string">"air"</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_result_unwrap_unchecked</span>)]</span>
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</span>(<span class="kw">unsafe</span> { <span class="ident">x</span>.<span class="ident">unwrap_unchecked</span>() }, <span class="string">"air"</span>); <span class="comment">// Undefined behavior!</span></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.map" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.map" class="fnname">map</a><U, F>(self, f: F) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(T) -> U, </span></h4><a href="#method.map" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#487" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Maps an <code>Option<T></code> to <code>Option<U></code> by applying a function to a contained value.</p>
<h1 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h1>
<p>Converts an <code>Option<</code><a href="../../std/string/struct.String.html"><code>String</code></a><code>></code> into an <code>Option<</code><a href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html" title="usize"><code>usize</code></a><code>></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::from</span>(<span class="string">"Hello, World!"</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="ident">maybe_some_len</span>, <span class="prelude-val">Some</span>(<span class="number">13</span>));</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.map_or" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.map_or" class="fnname">map_or</a><U, F>(self, default: U, f: F) -> U <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(T) -> U, </span></h4><a href="#method.map_or" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#514" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns the provided default result (if none),
or applies a function to the contained value (if any).</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="enum.Option.html#method.map_or_else"><code>map_or_else</code></a>,
which is lazily evaluated.</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">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">"foo"</span>);
<span class="macro">assert_eq!</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"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.map_or_else" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.map_or_else" class="fnname">map_or_else</a><U, D, F>(self, default: D, f: F) -> U <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(T) -> U,<br> D: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -> U, </span></h4><a href="#method.map_or_else" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#537" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Computes a default function result (if none), or
applies a different function to the contained value (if any).</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">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">"foo"</span>);
<span class="macro">assert_eq!</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"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ok_or" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.ok_or" class="fnname">ok_or</a><E>(self, err: E) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, E></h4><a href="#method.ok_or" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#567" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Transforms the <code>Option<T></code> into a <a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="Result<T, E>"><code>Result<T, E></code></a>, mapping <a href="enum.Option.html#variant.Some"><code>Some(v)</code></a> to
<a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html#variant.Ok"><code>Ok(v)</code></a> and <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> to <a href="https://doc.rust-lang.org/1.54.0/core/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="enum.Option.html#method.ok_or_else"><code>ok_or_else</code></a>, which is
lazily evaluated.</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">"foo"</span>);
<span class="macro">assert_eq!</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">"foo"</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ok_or_else" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.ok_or_else" class="fnname">ok_or_else</a><E, F>(self, err: F) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, E> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -> E, </span></h4><a href="#method.ok_or_else" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#592" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Transforms the <code>Option<T></code> into a <a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="Result<T, E>"><code>Result<T, E></code></a>, mapping <a href="enum.Option.html#variant.Some"><code>Some(v)</code></a> to
<a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html#variant.Ok"><code>Ok(v)</code></a> and <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> to <a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html#variant.Err"><code>Err(err())</code></a>.</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="string">"foo"</span>);
<span class="macro">assert_eq!</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">"foo"</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.iter" class="method has-srclink"><h4 class="code-header">pub const fn <a href="#method.iter" class="fnname">iter</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/option/struct.Iter.html" title="struct core::option::Iter">Iter</a><'_, T></h4><a href="#method.iter" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#617" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns an 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="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="ident">x</span>.<span class="ident">iter</span>().<span class="ident">next</span>(), <span class="prelude-val">Some</span>(<span class="kw-2">&</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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.iter_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.iter_mut" class="fnname">iter_mut</a>(&mut self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/option/struct.IterMut.html" title="struct core::option::IterMut">IterMut</a><'_, T></h4><a href="#method.iter_mut" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#638" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns a mutable iterator over the possibly contained value.</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="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">></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">></span> {},
}
<span class="macro">assert_eq!</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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.and" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.and" class="fnname">and</a><U>(self, optb: <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U></h4><a href="#method.and" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#669" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> if the option is <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>, otherwise returns <code>optb</code>.</p>
<h1 id="examples-17" class="section-header"><a href="#examples-17">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">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"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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"><</span><span class="ident">u32</span><span class="op">></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">"foo"</span>);
<span class="macro">assert_eq!</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">"foo"</span>);
<span class="macro">assert_eq!</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">"foo"</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></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"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.and_then" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.and_then" class="fnname">and_then</a><U, F>(self, f: F) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(T) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U>, </span></h4><a href="#method.and_then" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#694" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> if the option is <a href="enum.Option.html#variant.None" title="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-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">sq</span>(<span class="ident">x</span>: <span class="ident">u32</span>) <span class="op">-</span><span class="op">></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></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">></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span> { <span class="prelude-val">None</span> }
<span class="macro">assert_eq!</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="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="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="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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.filter" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.filter" class="fnname">filter</a><P>(self, predicate: P) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> P: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>T) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a>, </span></h4><span class="since" title="Stable since Rust version 1.27.0">1.27.0</span><a href="#method.filter" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#727" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> if the option is <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>, otherwise calls <code>predicate</code>
with the wrapped value and returns:</p>
<ul>
<li><a href="enum.Option.html#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="enum.Option.html#variant.None" title="None"><code>None</code></a> if <code>predicate</code> returns <code>false</code>.</li>
</ul>
<p>This function works similar to <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html#method.filter" title="Iterator::filter()"><code>Iterator::filter()</code></a>. You can imagine
the <code>Option<T></code> being an iterator over one or zero elements. <code>filter()</code>
lets you decide which elements to keep.</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">fn</span> <span class="ident">is_even</span>(<span class="ident">n</span>: <span class="kw-2">&</span><span class="ident">i32</span>) <span class="op">-</span><span class="op">></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="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="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="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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.or" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.or" class="fnname">or</a>(self, optb: <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><a href="#method.or" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#765" title="goto source code">[src]</a></div></summary><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="enum.Option.html#method.or_else"><code>or_else</code></a>, which is
lazily evaluated.</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">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="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="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="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"><</span><span class="ident">u32</span><span class="op">></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="ident">x</span>.<span class="ident">or</span>(<span class="ident">y</span>), <span class="prelude-val">None</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.or_else" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.or_else" class="fnname">or_else</a><F>(self, f: F) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>, </span></h4><a href="#method.or_else" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#787" title="goto source code">[src]</a></div></summary><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-21" class="section-header"><a href="#examples-21">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">></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="lifetime">'static</span> <span class="ident">str</span><span class="op">></span> { <span class="prelude-val">None</span> }
<span class="kw">fn</span> <span class="ident">vikings</span>() <span class="op">-</span><span class="op">></span> <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="lifetime">'static</span> <span class="ident">str</span><span class="op">></span> { <span class="prelude-val">Some</span>(<span class="string">"vikings"</span>) }
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(<span class="string">"barbarians"</span>).<span class="ident">or_else</span>(<span class="ident">vikings</span>), <span class="prelude-val">Some</span>(<span class="string">"barbarians"</span>));
<span class="macro">assert_eq!</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">"vikings"</span>));
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.xor" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.xor" class="fnname">xor</a>(self, optb: <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><span class="since" title="Stable since Rust version 1.37.0">1.37.0</span><a href="#method.xor" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#817" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a> if exactly one of <code>self</code>, <code>optb</code> is <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a>, otherwise returns <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>.</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="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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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"><</span><span class="ident">u32</span><span class="op">></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="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="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"><</span><span class="ident">u32</span><span class="op">></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"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</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></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.insert" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.insert" class="fnname">insert</a>(&mut self, value: T) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T</h4><span class="since" title="Stable since Rust version 1.53.0">1.53.0</span><a href="#method.insert" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#850" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Inserts <code>value</code> into the option then returns a mutable reference to it.</p>
<p>If the option already contains a value, the old value is dropped.</p>
<p>See also <a href="enum.Option.html#method.get_or_insert" title="Option::get_or_insert"><code>Option::get_or_insert</code></a>, which doesn’t update the value if
the option already contains <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a>.</p>
<h1 id="example" class="section-header"><a href="#example">Example</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">opt</span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="kw">let</span> <span class="ident">val</span> <span class="op">=</span> <span class="ident">opt</span>.<span class="ident">insert</span>(<span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">val</span>, <span class="number">1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">opt</span>.<span class="ident">unwrap</span>(), <span class="number">1</span>);
<span class="kw">let</span> <span class="ident">val</span> <span class="op">=</span> <span class="ident">opt</span>.<span class="ident">insert</span>(<span class="number">2</span>);
<span class="macro">assert_eq!</span>(<span class="kw-2">*</span><span class="ident">val</span>, <span class="number">2</span>);
<span class="kw-2">*</span><span class="ident">val</span> <span class="op">=</span> <span class="number">3</span>;
<span class="macro">assert_eq!</span>(<span class="ident">opt</span>.<span class="ident">unwrap</span>(), <span class="number">3</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.get_or_insert" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.get_or_insert" class="fnname">get_or_insert</a>(&mut self, value: T) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T</h4><span class="since" title="Stable since Rust version 1.20.0">1.20.0</span><a href="#method.get_or_insert" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#882" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Inserts <code>value</code> into the option if it is <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>, then
returns a mutable reference to the contained value.</p>
<p>See also <a href="enum.Option.html#method.insert" title="Option::insert"><code>Option::insert</code></a>, which updates the value even if
the option already contains <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a>.</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">&</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="ident">y</span>, <span class="kw-2">&</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="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">7</span>));</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.get_or_insert_default" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.get_or_insert_default" class="fnname">get_or_insert_default</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>, </span></h4><a href="#method.get_or_insert_default" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#907-909" title="goto source code">[src]</a></div><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>option_get_or_insert_default</code>)</div></div></summary><div class="docblock"><p>Inserts the default value into the option if it is <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>, then
returns a mutable reference to the contained value.</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="attribute">#![<span class="ident">feature</span>(<span class="ident">option_get_or_insert_default</span>)]</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">y</span>: <span class="kw-2">&</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_default</span>();
<span class="macro">assert_eq!</span>(<span class="ident">y</span>, <span class="kw-2">&</span><span class="number">0</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="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">7</span>));</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.get_or_insert_with" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.get_or_insert_with" class="fnname">get_or_insert_with</a><F>(&mut self, f: F) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>() -> T, </span></h4><span class="since" title="Stable since Rust version 1.20.0">1.20.0</span><a href="#method.get_or_insert_with" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#933" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Inserts a value computed from <code>f</code> into the option if it is <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>,
then returns a mutable reference to the contained value.</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">None</span>;
{
<span class="kw">let</span> <span class="ident">y</span>: <span class="kw-2">&</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="ident">y</span>, <span class="kw-2">&</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="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">7</span>));</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.take" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.take" class="fnname">take</a>(&mut self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><a href="#method.take" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#967" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Takes the value out of the option, leaving a <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> in its place.</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="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="ident">x</span>, <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</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"><</span><span class="ident">u32</span><span class="op">></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="ident">x</span>, <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</span>(<span class="ident">y</span>, <span class="prelude-val">None</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.replace" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.replace" class="fnname">replace</a>(&mut self, value: T) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><span class="since" title="Stable since Rust version 1.31.0">1.31.0</span><a href="#method.replace" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#990" title="goto source code">[src]</a></div></summary><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="enum.Option.html#variant.Some" title="Some"><code>Some</code></a> in its place without deinitializing either one.</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="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="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">5</span>));
<span class="macro">assert_eq!</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="ident">x</span>, <span class="prelude-val">Some</span>(<span class="number">3</span>));
<span class="macro">assert_eq!</span>(<span class="ident">old</span>, <span class="prelude-val">None</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.zip" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.zip" class="fnname">zip</a><U>(self, other: <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">(</a>T, U<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.tuple.html">)</a>></h4><span class="since" title="Stable since Rust version 1.46.0">1.46.0</span><a href="#method.zip" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1010" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Zips <code>self</code> with another <code>Option</code>.</p>
<p>If <code>self</code> is <code>Some(s)</code> and <code>other</code> is <code>Some(o)</code>, this method returns <code>Some((s, o))</code>.
Otherwise, <code>None</code> is returned.</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="prelude-val">Some</span>(<span class="number">1</span>);
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">"hi"</span>);
<span class="kw">let</span> <span class="ident">z</span> <span class="op">=</span> <span class="prelude-val">None</span>::<span class="op"><</span><span class="ident">u8</span><span class="op">></span>;
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">zip</span>(<span class="ident">y</span>), <span class="prelude-val">Some</span>((<span class="number">1</span>, <span class="string">"hi"</span>)));
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">zip</span>(<span class="ident">z</span>), <span class="prelude-val">None</span>);</pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.zip_with" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.zip_with" class="fnname">zip_with</a><U, F, R>(self, other: <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U>, f: F) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><R> <span class="where fmt-newline">where<br> F: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/function/trait.FnOnce.html" title="trait core::ops::function::FnOnce">FnOnce</a>(T, U) -> R, </span></h4><a href="#method.zip_with" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1046-1048" title="goto source code">[src]</a></div><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>option_zip</code>)</div></div></summary><div class="docblock"><p>Zips <code>self</code> and another <code>Option</code> with function <code>f</code>.</p>
<p>If <code>self</code> is <code>Some(s)</code> and <code>other</code> is <code>Some(o)</code>, this method returns <code>Some(f(s, o))</code>.
Otherwise, <code>None</code> is returned.</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="attribute">#![<span class="ident">feature</span>(<span class="ident">option_zip</span>)]</span>
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Debug</span>, <span class="ident">PartialEq</span>)]</span>
<span class="kw">struct</span> <span class="ident">Point</span> {
<span class="ident">x</span>: <span class="ident">f64</span>,
<span class="ident">y</span>: <span class="ident">f64</span>,
}
<span class="kw">impl</span> <span class="ident">Point</span> {
<span class="kw">fn</span> <span class="ident">new</span>(<span class="ident">x</span>: <span class="ident">f64</span>, <span class="ident">y</span>: <span class="ident">f64</span>) <span class="op">-</span><span class="op">></span> <span class="self">Self</span> {
<span class="self">Self</span> { <span class="ident">x</span>, <span class="ident">y</span> }
}
}
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">17.5</span>);
<span class="kw">let</span> <span class="ident">y</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="number">42.7</span>);
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">zip_with</span>(<span class="ident">y</span>, <span class="ident">Point::new</span>), <span class="prelude-val">Some</span>(<span class="ident">Point</span> { <span class="ident">x</span>: <span class="number">17.5</span>, <span class="ident">y</span>: <span class="number">42.7</span> }));
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">zip_with</span>(<span class="prelude-val">None</span>, <span class="ident">Point::new</span>), <span class="prelude-val">None</span>);</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-1" class="impl has-srclink"><h3 class="code-header in-band">impl<'_, T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'_ </a>T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>, </span></h3><a href="#impl-1" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1054-1071" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.copied" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.copied" class="fnname">copied</a>(self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><span class="since" title="Stable since Rust version 1.35.0">1.35.0</span><a href="#method.copied" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1068" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Maps an <code>Option<&T></code> to an <code>Option<T></code> by copying the contents of the
option.</p>
<h1 id="examples-30" class="section-header"><a href="#examples-30">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">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">&</span><span class="ident">x</span>);
<span class="macro">assert_eq!</span>(<span class="ident">opt_x</span>, <span class="prelude-val">Some</span>(<span class="kw-2">&</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="ident">copied</span>, <span class="prelude-val">Some</span>(<span class="number">12</span>));</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'_, T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'_ mut </a>T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>, </span></h3><a href="#impl-2" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1073-1090" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.copied-1" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.copied-1" class="fnname">copied</a>(self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><span class="since" title="Stable since Rust version 1.35.0">1.35.0</span><a href="#method.copied-1" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1087" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Maps an <code>Option<&mut T></code> to an <code>Option<T></code> by copying the contents of the
option.</p>
<h1 id="examples-31" class="section-header"><a href="#examples-31">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">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">&</span><span class="kw-2">mut</span> <span class="ident">x</span>);
<span class="macro">assert_eq!</span>(<span class="ident">opt_x</span>, <span class="prelude-val">Some</span>(<span class="kw-2">&</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="ident">copied</span>, <span class="prelude-val">Some</span>(<span class="number">12</span>));</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-3" class="impl has-srclink"><h3 class="code-header in-band">impl<'_, T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'_ </a>T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h3><a href="#impl-3" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1092-1109" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.cloned" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.cloned" class="fnname">cloned</a>(self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><a href="#method.cloned" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1106" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Maps an <code>Option<&T></code> to an <code>Option<T></code> by cloning the contents of the
option.</p>
<h1 id="examples-32" class="section-header"><a href="#examples-32">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">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">&</span><span class="ident">x</span>);
<span class="macro">assert_eq!</span>(<span class="ident">opt_x</span>, <span class="prelude-val">Some</span>(<span class="kw-2">&</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="ident">cloned</span>, <span class="prelude-val">Some</span>(<span class="number">12</span>));</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-4" class="impl has-srclink"><h3 class="code-header in-band">impl<'_, T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'_ mut </a>T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h3><a href="#impl-4" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1111-1128" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.cloned-1" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.cloned-1" class="fnname">cloned</a>(self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><span class="since" title="Stable since Rust version 1.26.0">1.26.0</span><a href="#method.cloned-1" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1125" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Maps an <code>Option<&mut T></code> to an <code>Option<T></code> by cloning the contents of the
option.</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="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">&</span><span class="kw-2">mut</span> <span class="ident">x</span>);
<span class="macro">assert_eq!</span>(<span class="ident">opt_x</span>, <span class="prelude-val">Some</span>(<span class="kw-2">&</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="ident">cloned</span>, <span class="prelude-val">Some</span>(<span class="number">12</span>));</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-5" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a>, </span></h3><a href="#impl-5" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1130-1165" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.unwrap_or_default" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.unwrap_or_default" class="fnname">unwrap_or_default</a>(self) -> T</h4><a href="#method.unwrap_or_default" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1159" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns the contained <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a> value or a default</p>
<p>Consumes the <code>self</code> argument then, if <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a>, returns the contained
value, otherwise if <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>, returns the <a href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html#tymethod.default">default value</a> for that
type.</p>
<h1 id="examples-34" class="section-header"><a href="#examples-34">Examples</a></h1>
<p>Converts a string to an integer, turning poorly-formed strings
into 0 (the default value for integers). <a href="https://doc.rust-lang.org/1.54.0/std/primitive.str.html#method.parse"><code>parse</code></a> converts
a string to any other type that implements <a href="https://doc.rust-lang.org/1.54.0/core/str/traits/trait.FromStr.html"><code>FromStr</code></a>, returning
<a href="enum.Option.html#variant.None" title="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">"1909"</span>;
<span class="kw">let</span> <span class="ident">bad_year_from_input</span> <span class="op">=</span> <span class="string">"190blarg"</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="number">1909</span>, <span class="ident">good_year</span>);
<span class="macro">assert_eq!</span>(<span class="number">0</span>, <span class="ident">bad_year</span>);</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-6" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/deref/trait.Deref.html" title="trait core::ops::deref::Deref">Deref</a>, </span></h3><a href="#impl-6" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1167-1186" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_deref" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_deref" class="fnname">as_deref</a>(&self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><&<T as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/deref/trait.Deref.html" title="trait core::ops::deref::Deref">Deref</a>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/ops/deref/trait.Deref.html#associatedtype.Target" title="type core::ops::deref::Deref::Target">Target</a>></h4><span class="since" title="Stable since Rust version 1.40.0">1.40.0</span><a href="#method.as_deref" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1183" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <code>Option<T></code> (or <code>&Option<T></code>) to <code>Option<&T::Target></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="https://doc.rust-lang.org/1.54.0/core/ops/deref/trait.Deref.html" title="Deref"><code>Deref</code></a>.</p>
<h1 id="examples-35" class="section-header"><a href="#examples-35">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">String</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">"hey"</span>.<span class="ident">to_owned</span>());
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">as_deref</span>(), <span class="prelude-val">Some</span>(<span class="string">"hey"</span>));
<span class="kw">let</span> <span class="ident">x</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">String</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</span>(<span class="ident">x</span>.<span class="ident">as_deref</span>(), <span class="prelude-val">None</span>);</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-7" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/deref/trait.DerefMut.html" title="trait core::ops::deref::DerefMut">DerefMut</a>, </span></h3><a href="#impl-7" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1188-1207" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.as_deref_mut" class="method has-srclink"><h4 class="code-header">pub fn <a href="#method.as_deref_mut" class="fnname">as_deref_mut</a>(&mut self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><&mut <T as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/deref/trait.Deref.html" title="trait core::ops::deref::Deref">Deref</a>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/ops/deref/trait.Deref.html#associatedtype.Target" title="type core::ops::deref::Deref::Target">Target</a>></h4><span class="since" title="Stable since Rust version 1.40.0">1.40.0</span><a href="#method.as_deref_mut" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1204" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <code>Option<T></code> (or <code>&mut Option<T></code>) to <code>Option<&mut T::Target></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-36" class="section-header"><a href="#examples-36">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"><</span><span class="ident">String</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">"hey"</span>.<span class="ident">to_owned</span>());
<span class="macro">assert_eq!</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">"HEY"</span>.<span class="ident">to_owned</span>().<span class="ident">as_mut_str</span>()));</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-8" class="impl has-srclink"><h3 class="code-header in-band">impl<T, E> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, E>></h3><a href="#impl-8" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1209-1236" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.transpose" class="method has-srclink"><h4 class="code-header">pub const fn <a href="#method.transpose" class="fnname">transpose</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>, E></h4><span class="since" title="Stable since Rust version 1.33.0">1.33.0</span><a href="#method.transpose" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1229" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Transposes an <code>Option</code> of a <a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="Result"><code>Result</code></a> into a <a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="Result"><code>Result</code></a> of an <code>Option</code>.</p>
<p><a href="enum.Option.html#variant.None" title="None"><code>None</code></a> will be mapped to <a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html#variant.Ok" title="Ok"><code>Ok</code></a><code>(</code><a href="enum.Option.html#variant.None" title="None"><code>None</code></a><code>)</code>.
<a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a><code>(</code><a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html#variant.Ok" title="Ok"><code>Ok</code></a><code>(_))</code> and <a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a><code>(</code><a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html#variant.Err" title="Err"><code>Err</code></a><code>(_))</code> will be mapped to
<a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html#variant.Ok" title="Ok"><code>Ok</code></a><code>(</code><a href="enum.Option.html#variant.Some" title="Some"><code>Some</code></a><code>(_))</code> and <a href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html#variant.Err" title="Err"><code>Err</code></a><code>(_)</code>.</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="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"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">i32</span><span class="op">></span>, <span class="ident">SomeErr</span><span class="op">></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"><</span><span class="prelude-ty">Result</span><span class="op"><</span><span class="ident">i32</span>, <span class="ident">SomeErr</span><span class="op">></span><span class="op">></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="ident">x</span>, <span class="ident">y</span>.<span class="ident">transpose</span>());</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-9" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>></h3><a href="#impl-9" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1700-1734" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.flatten" class="method has-srclink"><h4 class="code-header">pub const fn <a href="#method.flatten" class="fnname">flatten</a>(self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><span class="since" title="Stable since Rust version 1.40.0">1.40.0</span><a href="#method.flatten" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1728" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <code>Option<Option<T>></code> to <code>Option<T></code></p>
<h1 id="examples-38" class="section-header"><a href="#examples-38">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"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span><span class="op">></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="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"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span><span class="op">></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="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"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">None</span>;
<span class="macro">assert_eq!</span>(<span class="prelude-val">None</span>, <span class="ident">x</span>.<span class="ident">flatten</span>());</pre></div>
<p>Flattening only removes one level of nesting at a time:</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"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span><span class="op">></span><span class="op">></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="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="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></details></div></details><h2 id="trait-implementations" class="small-section-header">Trait Implementations<a href="#trait-implementations" class="anchor"></a></h2><div id="trait-implementations-list"><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Clone" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h3><a href="#impl-Clone" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1251-1267" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.clone" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html#tymethod.clone" class="fnname">clone</a>(&self) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><a href="#method.clone" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1253" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html#tymethod.clone">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.clone_from" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html#method.clone_from" class="fnname">clone_from</a>(&mut self, source: &<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>)</h4><a href="#method.clone_from" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1261" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Debug" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a>, </span></h3><a href="#impl-Debug" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Debug.html#tymethod.fmt" class="fnname">fmt</a>(&self, f: &mut <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a><'_>) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.unit.html">()</a>, <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/fmt/struct.Error.html" title="struct core::fmt::Error">Error</a>></h4><a href="#method.fmt" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/1.54.0/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Default" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><a href="#impl-Default" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1270-1283" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.default" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/default/trait.Default.html#tymethod.default" class="fnname">default</a>() -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><a href="#method.default" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1280" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns <a href="enum.Option.html#variant.None" title="Option::None"><code>None</code></a>.</p>
<h1 id="examples-40" class="section-header"><a href="#examples-40">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">opt</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u32</span><span class="op">></span> <span class="op">=</span> <span class="ident">Option::default</span>();
<span class="macro">assert!</span>(<span class="ident">opt</span>.<span class="ident">is_none</span>());</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-From%3C%26%27a%20Option%3CT%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><&'a <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>T></h3><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/1.54.0/src/core/option.rs.html#1346-1370" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from-2" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(o: &'a <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>T></h4><a href="#method.from-2" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1367" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <code>&Option<T></code> to <code>Option<&T></code>.</p>
<h1 id="examples-44" class="section-header"><a href="#examples-44">Examples</a></h1>
<p>Converts an <code>Option<</code><a href="../../std/string/struct.String.html"><code>String</code></a><code>></code> into an <code>Option<</code><a href="https://doc.rust-lang.org/1.54.0/std/primitive.usize.html" title="usize"><code>usize</code></a><code>></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">s</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">String</span><span class="op">></span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">String::from</span>(<span class="string">"Hello, Rustaceans!"</span>));
<span class="kw">let</span> <span class="ident">o</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">usize</span><span class="op">></span> <span class="op">=</span> <span class="ident">Option::from</span>(<span class="kw-2">&</span><span class="ident">s</span>).<span class="ident">map</span>(<span class="op">|</span><span class="ident">ss</span>: <span class="kw-2">&</span><span class="ident">String</span><span class="op">|</span> <span class="ident">ss</span>.<span class="ident">len</span>());
<span class="macro">println!</span>(<span class="string">"Can still print s: {:?}"</span>, <span class="ident">s</span>);
<span class="macro">assert_eq!</span>(<span class="ident">o</span>, <span class="prelude-val">Some</span>(<span class="number">18</span>));</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-From%3C%26%27a%20mut%20Option%3CT%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><&'a mut <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a mut </a>T></h3><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/1.54.0/src/core/option.rs.html#1373-1392" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(o: &'a mut <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a mut </a>T></h4><a href="#method.from" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1389" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Converts from <code>&mut Option<T></code> to <code>Option<&mut T></code></p>
<h1 id="examples-42" class="section-header"><a href="#examples-42">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">s</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="ident">String::from</span>(<span class="string">"Hello"</span>));
<span class="kw">let</span> <span class="ident">o</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">String</span><span class="op">></span> <span class="op">=</span> <span class="ident">Option::from</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">s</span>);
<span class="kw">match</span> <span class="ident">o</span> {
<span class="prelude-val">Some</span>(<span class="ident">t</span>) <span class="op">=</span><span class="op">></span> <span class="kw-2">*</span><span class="ident">t</span> <span class="op">=</span> <span class="ident">String::from</span>(<span class="string">"Hello, Rustaceans!"</span>),
<span class="prelude-val">None</span> <span class="op">=</span><span class="op">></span> (),
}
<span class="macro">assert_eq!</span>(<span class="ident">s</span>, <span class="prelude-val">Some</span>(<span class="ident">String::from</span>(<span class="string">"Hello, Rustaceans!"</span>)));</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-From%3CT%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><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/1.54.0/src/core/option.rs.html#1330-1343" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from-1" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(val: T) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><a href="#method.from-1" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1340" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Copies <code>val</code> into a new <code>Some</code>.</p>
<h1 id="examples-43" class="section-header"><a href="#examples-43">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">o</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">u8</span><span class="op">></span> <span class="op">=</span> <span class="ident">Option::from</span>(<span class="number">67</span>);
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(<span class="number">67</span>), <span class="ident">o</span>);</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-FromIterator%3COption%3CA%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<A, V> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.FromIterator.html" title="trait core::iter::traits::collect::FromIterator">FromIterator</a><<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><A>> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><V> <span class="where fmt-newline">where<br> V: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.FromIterator.html" title="trait core::iter::traits::collect::FromIterator">FromIterator</a><A>, </span></h3><a href="#impl-FromIterator%3COption%3CA%3E%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1569-1637" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_iter" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.FromIterator.html#tymethod.from_iter" class="fnname">from_iter</a><I>(iter: I) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><V> <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a><Item = <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><A>>, </span></h4><a href="#method.from_iter" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1631" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Takes each element in the <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="Iterator"><code>Iterator</code></a>: if it is <a href="enum.Option.html#variant.None" title="Option::None"><code>None</code></a>,
no further elements are taken, and the <a href="enum.Option.html#variant.None" title="Option::None"><code>None</code></a> is
returned. Should no <a href="enum.Option.html#variant.None" title="Option::None"><code>None</code></a> occur, a container with the
values of each <a href="enum.Option.html" title="Option"><code>Option</code></a> is returned.</p>
<h1 id="examples-39" class="section-header"><a href="#examples-39">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="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"><</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u16</span><span class="op">></span><span class="op">></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="ident">res</span>, <span class="prelude-val">Some</span>(<span class="macro">vec!</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="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"><</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u16</span><span class="op">></span><span class="op">></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="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="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"><</span><span class="ident">Vec</span><span class="op"><</span><span class="ident">u16</span><span class="op">></span><span class="op">></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="ident">res</span>, <span class="prelude-val">None</span>);
<span class="macro">assert_eq!</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></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-FromResidual%3C%3COption%3CT%3E%20as%20Try%3E%3A%3AResidual%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.FromResidual.html" title="trait core::ops::try_trait::FromResidual">FromResidual</a><<<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html" title="trait core::ops::try_trait::Try">Try</a>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#associatedtype.Residual" title="type core::ops::try_trait::Try::Residual">Residual</a>> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><a href="#impl-FromResidual%3C%3COption%3CT%3E%20as%20Try%3E%3A%3AResidual%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1691-1698" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_residual" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.FromResidual.html#tymethod.from_residual" class="fnname">from_residual</a>(residual: <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="enum" href="https://doc.rust-lang.org/1.54.0/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a>>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><a href="#method.from_residual" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1693" title="goto source code">[src]</a></div></summary><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>try_trait_v2</code>)</div></div><div class='docblock'><p>Constructs the type from a compatible <code>Residual</code> type. <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.FromResidual.html#tymethod.from_residual">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Hash" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>, </span></h3><a href="#impl-Hash" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.hash" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html#tymethod.hash" class="fnname">hash</a><__H>(&self, state: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>__H) <span class="where fmt-newline">where<br> __H: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>, </span></h4><a href="#method.hash" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Feeds this value into the given <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hasher.html" title="Hasher"><code>Hasher</code></a>. <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.hash_slice" class="method trait-impl has-srclink"><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html#method.hash_slice" class="fnname">hash_slice</a><H>(data: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.slice.html">&[Self]</a>, state: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>H) <span class="where fmt-newline">where<br> H: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>, </span></h4><span class="since" title="Stable since Rust version 1.3.0">1.3.0</span><a href="#method.hash_slice" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/hash/mod.rs.html#211-213" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Feeds a slice of this type into the given <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hasher.html" title="Hasher"><code>Hasher</code></a>. <a href="https://doc.rust-lang.org/1.54.0/core/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-IntoIterator" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for &'a <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><a href="#impl-IntoIterator" 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/1.54.0/src/core/option.rs.html#1310-1317" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Item" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item" class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a </a>T</h4><a href="#associatedtype.Item" class="anchor"></a></div></summary><div class='docblock'><p>The type of the elements being iterated over.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.IntoIter" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" class="type">IntoIter</a> = <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/option/struct.Iter.html" title="struct core::option::Iter">Iter</a><'a, T></h4><a href="#associatedtype.IntoIter" class="anchor"></a></div></summary><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_iter" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter" class="fnname">into_iter</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/option/struct.Iter.html" title="struct core::option::Iter">Iter</a><'a, T></h4><a href="#method.into_iter" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1314" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Creates an iterator from a value. <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-IntoIterator-1" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><a href="#impl-IntoIterator-1" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1286-1307" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_iter-1" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter" class="fnname">into_iter</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/option/struct.IntoIter.html" title="struct core::option::IntoIter">IntoIter</a><T></h4><a href="#method.into_iter-1" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1304" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Returns a consuming iterator over the possibly contained value.</p>
<h1 id="examples-41" class="section-header"><a href="#examples-41">Examples</a></h1>
<div class="example-wrap"><pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="prelude-val">Some</span>(<span class="string">"string"</span>);
<span class="kw">let</span> <span class="ident">v</span>: <span class="ident">Vec</span><span class="op"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></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="ident">v</span>, [<span class="string">"string"</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"><</span><span class="kw-2">&</span><span class="ident">str</span><span class="op">></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="ident">v</span>.<span class="ident">is_empty</span>());</pre></div>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Item-1" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item" class="type">Item</a> = T</h4><a href="#associatedtype.Item-1" class="anchor"></a></div></summary><div class='docblock'><p>The type of the elements being iterated over.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.IntoIter-1" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" class="type">IntoIter</a> = <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/option/struct.IntoIter.html" title="struct core::option::IntoIter">IntoIter</a><T></h4><a href="#associatedtype.IntoIter-1" class="anchor"></a></div></summary><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-IntoIterator-2" class="impl has-srclink"><h3 class="code-header in-band">impl<'a, T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html" title="trait core::iter::traits::collect::IntoIterator">IntoIterator</a> for &'a mut <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><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/1.54.0/src/core/option.rs.html#1320-1327" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Item-2" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.Item" class="type">Item</a> = <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&'a mut </a>T</h4><a href="#associatedtype.Item-2" class="anchor"></a></div></summary><div class='docblock'><p>The type of the elements being iterated over.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.IntoIter-2" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#associatedtype.IntoIter" class="type">IntoIter</a> = <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/option/struct.IterMut.html" title="struct core::option::IterMut">IterMut</a><'a, T></h4><a href="#associatedtype.IntoIter-2" class="anchor"></a></div></summary><div class='docblock'><p>Which kind of iterator are we turning this into?</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into_iter-2" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter" class="fnname">into_iter</a>(self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/option/struct.IterMut.html" title="struct core::option::IterMut">IterMut</a><'a, T></h4><a href="#method.into_iter-2" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1324" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Creates an iterator from a value. <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/collect/trait.IntoIterator.html#tymethod.into_iter">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Ord" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html" title="trait core::cmp::Ord">Ord</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html" title="trait core::cmp::Ord">Ord</a>, </span></h3><a href="#impl-Ord" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.cmp" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html#tymethod.cmp" class="fnname">cmp</a>(&self, other: &<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/cmp/enum.Ordering.html" title="enum core::cmp::Ordering">Ordering</a></h4><a href="#method.cmp" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method returns an <a href="https://doc.rust-lang.org/1.54.0/core/cmp/enum.Ordering.html" title="Ordering"><code>Ordering</code></a> between <code>self</code> and <code>other</code>. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html#tymethod.cmp">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.max" class="method trait-impl has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html#method.max" class="fnname">max</a>(self, other: Self) -> Self</h4><span class="since" title="Stable since Rust version 1.21.0">1.21.0</span><a href="#method.max" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/cmp.rs.html#738-740" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Compares and returns the maximum of two values. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html#method.max">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.min" class="method trait-impl has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html#method.min" class="fnname">min</a>(self, other: Self) -> Self</h4><span class="since" title="Stable since Rust version 1.21.0">1.21.0</span><a href="#method.min" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/cmp.rs.html#758-760" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Compares and returns the minimum of two values. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html#method.min">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.clamp" class="method trait-impl has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html#method.clamp" class="fnname">clamp</a>(self, min: Self, max: Self) -> Self</h4><span class="since" title="Stable since Rust version 1.50.0">1.50.0</span><a href="#method.clamp" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/cmp.rs.html#783-785" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Restrict a value to a certain interval. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Ord.html#method.clamp">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-PartialEq%3COption%3CT%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a><<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a><T>, </span></h3><a href="#impl-PartialEq%3COption%3CT%3E%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.eq" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html#tymethod.eq" class="fnname">eq</a>(&self, other: &<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.eq" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used
by <code>==</code>. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ne" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialEq.html#method.ne" class="fnname">ne</a>(&self, other: &<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.ne" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method tests for <code>!=</code>.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-PartialOrd%3COption%3CT%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html" title="trait core::cmp::PartialOrd">PartialOrd</a><<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html" title="trait core::cmp::PartialOrd">PartialOrd</a><T>, </span></h3><a href="#impl-PartialOrd%3COption%3CT%3E%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.partial_cmp" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp" class="fnname">partial_cmp</a>(&self, other: &<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="enum" href="https://doc.rust-lang.org/1.54.0/core/cmp/enum.Ordering.html" title="enum core::cmp::Ordering">Ordering</a>></h4><a href="#method.partial_cmp" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method returns an ordering between <code>self</code> and <code>other</code> values if one exists. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#tymethod.partial_cmp">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.lt" class="method trait-impl has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#method.lt" class="fnname">lt</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.lt" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/cmp.rs.html#978" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method tests less than (for <code>self</code> and <code>other</code>) and is used by the <code><</code> operator. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#method.lt">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.le" class="method trait-impl has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#method.le" class="fnname">le</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.le" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/cmp.rs.html#997" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method tests less than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code><=</code>
operator. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#method.le">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.gt" class="method trait-impl has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#method.gt" class="fnname">gt</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.gt" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/cmp.rs.html#1019" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method tests greater than (for <code>self</code> and <code>other</code>) and is used by the <code>></code> operator. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#method.gt">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ge" class="method trait-impl has-srclink"><h4 class="code-header"><div class="code-attribute">#[must_use]</div>fn <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#method.ge" class="fnname">ge</a>(&self, other: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>Rhs) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.bool.html">bool</a></h4><a href="#method.ge" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/cmp.rs.html#1038" title="goto source code">[src]</a></div></summary><div class='docblock'><p>This method tests greater than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>>=</code>
operator. <a href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.PartialOrd.html#method.ge">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Product%3COption%3CU%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/accum/trait.Product.html" title="trait core::iter::traits::accum::Product">Product</a><<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U>> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/accum/trait.Product.html" title="trait core::iter::traits::accum::Product">Product</a><U>, </span></h3><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/1.54.0/src/core/iter/traits/accum.rs.html#220-233" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.product" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/accum/trait.Product.html#tymethod.product" class="fnname">product</a><I>(iter: I) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a><Item = <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U>>, </span></h4><a href="#method.product" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/iter/traits/accum.rs.html#227-229" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Takes each element in the <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="Iterator"><code>Iterator</code></a>: if it is a <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>, no further
elements are taken, and the <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> is returned. Should no <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>
occur, the product of all elements is returned.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Sum%3COption%3CU%3E%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/accum/trait.Sum.html" title="trait core::iter::traits::accum::Sum">Sum</a><<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U>> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/accum/trait.Sum.html" title="trait core::iter::traits::accum::Sum">Sum</a><U>, </span></h3><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/1.54.0/src/core/iter/traits/accum.rs.html#193-217" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.sum" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/accum/trait.Sum.html#tymethod.sum" class="fnname">sum</a><I>(iter: I) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> I: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator">Iterator</a><Item = <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><U>>, </span></h4><a href="#method.sum" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/iter/traits/accum.rs.html#211-213" title="goto source code">[src]</a></div></summary><div class="docblock"><p>Takes each element in the <a href="https://doc.rust-lang.org/1.54.0/core/iter/traits/iterator/trait.Iterator.html" title="Iterator"><code>Iterator</code></a>: if it is a <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>, no further
elements are taken, and the <a href="enum.Option.html#variant.None" title="None"><code>None</code></a> is returned. Should no <a href="enum.Option.html#variant.None" title="None"><code>None</code></a>
occur, the sum of all elements is returned.</p>
<h1 id="examples-45" class="section-header"><a href="#examples-45">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="string">"have"</span>, <span class="string">"a"</span>, <span class="string">"great"</span>, <span class="string">"day"</span>];
<span class="kw">let</span> <span class="ident">total</span>: <span class="prelude-ty">Option</span><span class="op"><</span><span class="ident">usize</span><span class="op">></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">'a'</span>)).<span class="ident">sum</span>();
<span class="macro">assert_eq!</span>(<span class="ident">total</span>, <span class="prelude-val">Some</span>(<span class="number">5</span>));</pre></div>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Try" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html" title="trait core::ops::try_trait::Try">Try</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><a href="#impl-Try" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1672-1688" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Output" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#associatedtype.Output" class="type">Output</a> = T</h4><a href="#associatedtype.Output" class="anchor"></a></div></summary><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>try_trait_v2</code>)</div></div><div class='docblock'><p>The type of the value produced by <code>?</code> when <em>not</em> short-circuiting.</p>
</div></details><details class="rustdoc-toggle" open><summary><div id="associatedtype.Residual" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#associatedtype.Residual" class="type">Residual</a> = <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><<a class="enum" href="https://doc.rust-lang.org/1.54.0/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a>></h4><a href="#associatedtype.Residual" class="anchor"></a></div></summary><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>try_trait_v2</code>)</div></div><div class='docblock'><p>The type of the value passed to <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.FromResidual.html#tymethod.from_residual" title="FromResidual::from_residual"><code>FromResidual::from_residual</code></a>
as part of <code>?</code> when short-circuiting. <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#associatedtype.Residual">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from_output" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#tymethod.from_output" class="fnname">from_output</a>(output: <<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html" title="trait core::ops::try_trait::Try">Try</a>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#associatedtype.Output" title="type core::ops::try_trait::Try::Output">Output</a>) -> <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h4><a href="#method.from_output" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1677" title="goto source code">[src]</a></div></summary><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>try_trait_v2</code>)</div></div><div class='docblock'><p>Constructs the type from its <code>Output</code> type. <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#tymethod.from_output">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.branch" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#tymethod.branch" class="fnname">branch</a>(<br> self<br>) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/ops/control_flow/enum.ControlFlow.html" title="enum core::ops::control_flow::ControlFlow">ControlFlow</a><<<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html" title="trait core::ops::try_trait::Try">Try</a>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#associatedtype.Residual" title="type core::ops::try_trait::Try::Residual">Residual</a>, <<a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html" title="trait core::ops::try_trait::Try">Try</a>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#associatedtype.Output" title="type core::ops::try_trait::Try::Output">Output</a>></h4><a href="#method.branch" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#1682" title="goto source code">[src]</a></div></summary><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>try_trait_v2</code>)</div></div><div class='docblock'><p>Used in <code>?</code> to decide whether the operator should produce a value
(because this returned <a href="https://doc.rust-lang.org/1.54.0/core/ops/control_flow/enum.ControlFlow.html#variant.Continue" title="ControlFlow::Continue"><code>ControlFlow::Continue</code></a>)
or propagate a value back to the caller
(because this returned <a href="https://doc.rust-lang.org/1.54.0/core/ops/control_flow/enum.ControlFlow.html#variant.Break" title="ControlFlow::Break"><code>ControlFlow::Break</code></a>). <a href="https://doc.rust-lang.org/1.54.0/core/ops/try_trait/trait.Try.html#tymethod.branch">Read more</a></p>
</div></details></div></details><div id="impl-Copy" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Copy.html" title="trait core::marker::Copy">Copy</a>, </span></h3><a href="#impl-Copy" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div><div id="impl-Eq" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>, </span></h3><a href="#impl-Eq" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div><div id="impl-StructuralEq" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.StructuralEq.html" title="trait core::marker::StructuralEq">StructuralEq</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><a href="#impl-StructuralEq" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></div><div id="impl-StructuralPartialEq" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.StructuralPartialEq.html" title="trait core::marker::StructuralPartialEq">StructuralPartialEq</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T></h3><a href="#impl-StructuralPartialEq" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/option.rs.html#160" title="goto source code">[src]</a></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"><div id="impl-RefUnwindSafe" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.RefUnwindSafe.html" title="trait std::panic::RefUnwindSafe">RefUnwindSafe</a>, </span></h3><a href="#impl-RefUnwindSafe" class="anchor"></a></div><div id="impl-Send" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>, </span></h3><a href="#impl-Send" class="anchor"></a></div><div id="impl-Sync" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>, </span></h3><a href="#impl-Sync" class="anchor"></a></div><div id="impl-Unpin" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a>, </span></h3><a href="#impl-Unpin" class="anchor"></a></div><div id="impl-UnwindSafe" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a> for <a class="enum" href="enum.Option.html" title="enum enum_primitive::Option">Option</a><T> <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/std/panic/trait.UnwindSafe.html" title="trait std::panic::UnwindSafe">UnwindSafe</a>, </span></h3><a href="#impl-UnwindSafe" class="anchor"></a></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"><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Any" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br> T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3><a href="#impl-Any" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/any.rs.html#131-135" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.type_id" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/any/trait.Any.html#tymethod.type_id" class="fnname">type_id</a>(&self) -> <a class="struct" href="https://doc.rust-lang.org/1.54.0/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4><a href="#method.type_id" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/any.rs.html#132" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/1.54.0/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Borrow%3CT%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3><a href="#impl-Borrow%3CT%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/borrow.rs.html#208-213" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.borrow" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&</a>T</h4><a href="#method.borrow" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/borrow.rs.html#210" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-BorrowMut%3CT%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a><T> for T <span class="where fmt-newline">where<br> T: ?<a class="trait" href="https://doc.rust-lang.org/1.54.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>, </span></h3><a href="#impl-BorrowMut%3CT%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/borrow.rs.html#216-220" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.borrow_mut" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fnname">borrow_mut</a>(&mut self) -> <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T</h4><a href="#method.borrow_mut" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/borrow.rs.html#217" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.54.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-From%3C!%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.never.html">!</a>> for T</h3><a href="#impl-From%3C!%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#559-563" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from-3" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(t: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.never.html">!</a>) -> T</h4><a href="#method.from-3" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#560" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-From%3CT%3E-1" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for T</h3><a href="#impl-From%3CT%3E-1" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#544-548" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from-4" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(t: T) -> T</h4><a href="#method.from-4" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#545" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-Into%3CU%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.From.html" title="trait core::convert::From">From</a><T>, </span></h3><a href="#impl-Into%3CU%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#533-540" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html#tymethod.into" class="fnname">into</a>(self) -> U</h4><a href="#method.into" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#537" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-ToOwned" class="impl has-srclink"><h3 class="code-header in-band">impl<T> <a class="trait" href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T <span class="where fmt-newline">where<br> T: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>, </span></h3><a href="#impl-ToOwned" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/alloc/borrow.rs.html#84-96" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Owned" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#associatedtype.Owned" class="type">Owned</a> = T</h4><a href="#associatedtype.Owned" class="anchor"></a></div></summary><div class='docblock'><p>The resulting type after obtaining ownership.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.to_owned" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned" class="fnname">to_owned</a>(&self) -> T</h4><a href="#method.to_owned" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/alloc/borrow.rs.html#89" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.clone_into" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#method.clone_into" class="fnname">clone_into</a>(&self, target: <a class="primitive" href="https://doc.rust-lang.org/1.54.0/std/primitive.reference.html">&mut </a>T)</h4><a href="#method.clone_into" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/alloc/borrow.rs.html#93" title="goto source code">[src]</a></div></summary><div class="item-info"><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'><p>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/1.54.0/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-TryFrom%3CU%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a><T>, </span></h3><a href="#impl-TryFrom%3CU%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#581-590" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#associatedtype.Error" class="type">Error</a> = <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4><a href="#associatedtype.Error" class="anchor"></a></div></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_from" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#tymethod.try_from" class="fnname">try_from</a>(value: U) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, <T as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><U>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4><a href="#method.try_from" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#587" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle"><summary><div id="impl-TryInto%3CU%3E" class="impl has-srclink"><h3 class="code-header in-band">impl<T, U> <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a><U> for T <span class="where fmt-newline">where<br> U: <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>, </span></h3><a href="#impl-TryInto%3CU%3E" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#567-576" title="goto source code">[src]</a></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error-1" class="type trait-impl has-srclink"><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryInto.html#associatedtype.Error" class="type">Error</a> = <U as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4><a href="#associatedtype.Error-1" class="anchor"></a></div></summary><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_into" class="method trait-impl has-srclink"><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryInto.html#tymethod.try_into" class="fnname">try_into</a>(self) -> <a class="enum" href="https://doc.rust-lang.org/1.54.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a><U, <U as <a class="trait" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a><T>>::<a class="type" href="https://doc.rust-lang.org/1.54.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>></h4><a href="#method.try_into" class="anchor"></a><a class="srclink" href="https://doc.rust-lang.org/1.54.0/src/core/convert/mod.rs.html#573" title="goto source code">[src]</a></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details></div></section><section id="search" class="content hidden"></section><div id="rustdoc-vars" data-root-path="../" data-current-crate="enum_primitive" data-search-index-js="../search-index.js" data-search-js="../search.js"></div><script src="../main.js"></script></body></html>