evan/ludum-dare-50
Archived
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
This repository has been archived on 2022-04-04. You can view files and clone it, but cannot push or open issues or pull requests.
ludum-dare-50/rustdoc/crossbeam_channel/struct.Select.html

410 lines
83 KiB
HTML
Raw Blame History

This file contains ambiguous Unicode characters

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

<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="Selects from a set of channel operations."><meta name="keywords" content="rust, rustlang, rust-lang, Select"><title>Select in crossbeam_channel - Rust</title><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceSerif4-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../FiraSans-Regular.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../FiraSans-Medium.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceCodePro-Regular.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceSerif4-Bold.ttf.woff2"><link rel="preload" as="font" type="font/woff2" crossorigin href="../SourceCodePro-Semibold.ttf.woff2"><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="../ayu.css" disabled><link rel="stylesheet" type="text/css" href="../dark.css" disabled><link rel="stylesheet" type="text/css" href="../light.css" id="themeStyle"><script id="default-settings" ></script><script src="../storage.js"></script><script src="../crates.js"></script><script defer src="../main.js"></script>
<noscript><link rel="stylesheet" href="../noscript.css"></noscript><link rel="alternate icon" type="image/png" href="../favicon-16x16.png"><link rel="alternate icon" type="image/png" href="../favicon-32x32.png"><link rel="icon" type="image/svg+xml" href="../favicon.svg"></head><body class="rustdoc struct"><!--[if lte IE 11]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu" role="button">&#9776;</div><a class="sidebar-logo" href="../crossbeam_channel/index.html"><div class="logo-container"><img class="rust-logo" src="../rust-logo.png" alt="logo"></div>
</a><h2 class="location">Struct Select</h2><div class="sidebar-elems"><div class="block items"><h3 class="sidebar-title"><a href="#implementations">Methods</a></h3><div class="sidebar-links"><a href="#method.new">new</a><a href="#method.ready">ready</a><a href="#method.ready_deadline">ready_deadline</a><a href="#method.ready_timeout">ready_timeout</a><a href="#method.recv">recv</a><a href="#method.remove">remove</a><a href="#method.select">select</a><a href="#method.select_deadline">select_deadline</a><a href="#method.select_timeout">select_timeout</a><a href="#method.send">send</a><a href="#method.try_ready">try_ready</a><a href="#method.try_select">try_select</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-Debug">Debug</a><a href="#impl-Default">Default</a><a href="#impl-Send">Send</a><a href="#impl-Sync">Sync</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-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&lt;T&gt;</a><a href="#impl-BorrowMut%3CT%3E">BorrowMut&lt;T&gt;</a><a href="#impl-From%3CT%3E">From&lt;T&gt;</a><a href="#impl-Into%3CU%3E">Into&lt;U&gt;</a><a href="#impl-ToOwned">ToOwned</a><a href="#impl-TryFrom%3CU%3E">TryFrom&lt;U&gt;</a><a href="#impl-TryInto%3CU%3E">TryInto&lt;U&gt;</a></div></div><h2 class="location">Other items in<br><a href="index.html">crossbeam_channel</a></h2><div id="sidebar-vars" data-name="Select" data-ty="struct" data-relpath=""></div><script defer src="sidebar-items.js"></script></div></nav><main><div class="width-limiter"><div class="sub-container"><a class="sub-logo-container" href="../crossbeam_channel/index.html"><img class="rust-logo" src="../rust-logo.png" alt="logo"></a><nav class="sub"><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!" aria-haspopup="menu" title="themes"><img width="18" height="18" alt="Pick another theme!" src="../brush.svg"></button><div id="theme-choices" role="menu"></div></div><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" 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 width="18" height="18" alt="Change settings" src="../wheel.svg"></a></div></form></nav></div><section id="main-content" class="content"><h1 class="fqn"><span class="in-band">Struct <a href="index.html">crossbeam_channel</a>::<wbr><a class="struct" href="#">Select</a><button id="copy-path" onclick="copy_path(this)" title="Copy item path to clipboard"><img src="../clipboard.svg" width="19" height="18" alt="Copy item path"></button></span><span class="out-of-band"><span id="render-detail"><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class="inner">&#x2212;</span>]</a></span><a class="srclink" href="../src/crossbeam_channel/select.rs.html#592-598" title="goto source code">[src]</a></span></h1><div class="docblock item-decl"><pre class="rust struct"><code>pub struct Select&lt;'a&gt; { /* fields omitted */ }</code></pre></div><details class="rustdoc-toggle top-doc" open><summary class="hideme"><span>Expand description</span></summary><div class="docblock"><p>Selects from a set of channel operations.</p>
<p><code>Select</code> allows you to define a set of channel operations, wait until any one of them becomes
ready, and finally execute it. If multiple operations are ready at the same time, a random one
among them is selected.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready even
when it will simply return an error because the channel is disconnected.</p>
<p>The <a href="macro.select.html" title="select!"><code>select!</code></a> macro is a convenience wrapper around <code>Select</code>. However, it cannot select over a
dynamically created list of channel operations.</p>
<p>Once a list of operations has been built with <code>Select</code>, there are two different ways of
proceeding:</p>
<ul>
<li>
<p>Select an operation with <a href="struct.Select.html#method.try_select"><code>try_select</code></a>, <a href="struct.Select.html#method.select"><code>select</code></a>, or <a href="struct.Select.html#method.select_timeout"><code>select_timeout</code></a>. If successful,
the returned selected operation has already begun and <strong>must</strong> be completed. If we don’t
complete it, a panic will occur.</p>
</li>
<li>
<p>Wait for an operation to become ready with <a href="struct.Select.html#method.try_ready"><code>try_ready</code></a>, <a href="struct.Select.html#method.ready"><code>ready</code></a>, or <a href="struct.Select.html#method.ready_timeout"><code>ready_timeout</code></a>. If
successful, we may attempt to execute the operation, but are not obliged to. In fact, it’s
possible for another thread to make the operation not ready just before we try executing it,
so it’s wise to use a retry loop. However, note that these methods might return with success
spuriously, so it’s a good idea to always double check if the operation is really ready.</p>
</li>
</ul>
<h2 id="examples" class="section-header"><a href="#examples">Examples</a></h2>
<p>Use <a href="struct.Select.html#method.select"><code>select</code></a> to receive a message from a list of receivers:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">Receiver</span>, <span class="ident">RecvError</span>, <span class="ident">Select</span>};
<span class="kw">fn</span> <span class="ident">recv_multiple</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span>(<span class="ident">rs</span>: <span class="kw-2">&amp;</span>[<span class="ident">Receiver</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span>]) -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span><span class="ident">T</span>, <span class="ident">RecvError</span><span class="op">&gt;</span> {
<span class="comment">// Build a list of operations.</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">for</span> <span class="ident">r</span> <span class="kw">in</span> <span class="ident">rs</span> {
<span class="ident">sel</span>.<span class="ident">recv</span>(<span class="ident">r</span>);
}
<span class="comment">// Complete the selected operation.</span>
<span class="kw">let</span> <span class="ident">oper</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">select</span>();
<span class="kw">let</span> <span class="ident">index</span> <span class="op">=</span> <span class="ident">oper</span>.<span class="ident">index</span>();
<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">rs</span>[<span class="ident">index</span>])
}</code></pre></div>
<p>Use <a href="struct.Select.html#method.ready"><code>ready</code></a> to receive a message from a list of receivers:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">Receiver</span>, <span class="ident">RecvError</span>, <span class="ident">Select</span>};
<span class="kw">fn</span> <span class="ident">recv_multiple</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span>(<span class="ident">rs</span>: <span class="kw-2">&amp;</span>[<span class="ident">Receiver</span><span class="op">&lt;</span><span class="ident">T</span><span class="op">&gt;</span>]) -&gt; <span class="prelude-ty">Result</span><span class="op">&lt;</span><span class="ident">T</span>, <span class="ident">RecvError</span><span class="op">&gt;</span> {
<span class="comment">// Build a list of operations.</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">for</span> <span class="ident">r</span> <span class="kw">in</span> <span class="ident">rs</span> {
<span class="ident">sel</span>.<span class="ident">recv</span>(<span class="ident">r</span>);
}
<span class="kw">loop</span> {
<span class="comment">// Wait until a receive operation becomes ready and try executing it.</span>
<span class="kw">let</span> <span class="ident">index</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">ready</span>();
<span class="kw">let</span> <span class="ident">res</span> <span class="op">=</span> <span class="ident">rs</span>[<span class="ident">index</span>].<span class="ident">try_recv</span>();
<span class="comment">// If the operation turns out not to be ready, retry.</span>
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Err</span>(<span class="ident">e</span>) <span class="op">=</span> <span class="ident">res</span> {
<span class="kw">if</span> <span class="ident">e</span>.<span class="ident">is_empty</span>() {
<span class="kw">continue</span>;
}
}
<span class="comment">// Success!</span>
<span class="kw">return</span> <span class="ident">res</span>.<span class="ident">map_err</span>(<span class="op">|</span><span class="kw">_</span><span class="op">|</span> <span class="ident">RecvError</span>);
}
}</code></pre></div>
</div></details><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"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#603-1097" title="goto source code">[src]</a></div><a href="#impl" class="anchor"></a><h3 class="code-header in-band">impl&lt;'a&gt; <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.new" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#616-621" title="goto source code">[src]</a></div><a href="#method.new" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.new" class="fnname">new</a>() -&gt; <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h4></div></summary><div class="docblock"><p>Creates an empty list of channel operations for selection.</p>
<h5 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_channel::Select</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="comment">// The list of operations is empty, which means no operation can be selected.</span>
<span class="macro">assert!</span>(<span class="ident">sel</span>.<span class="ident">try_select</span>().<span class="ident">is_err</span>());</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.send" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#637-643" title="goto source code">[src]</a></div><a href="#method.send" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.send" class="fnname">send</a>&lt;T&gt;(&amp;mut self, s: &amp;'a <a class="struct" href="struct.Sender.html" title="struct crossbeam_channel::Sender">Sender</a>&lt;T&gt;) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Adds a send operation.</p>
<p>Returns the index of the added operation.</p>
<h5 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s</span>, <span class="ident">r</span>) <span class="op">=</span> <span class="ident">unbounded</span>::<span class="op">&lt;</span><span class="ident">i32</span><span class="op">&gt;</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">index</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">send</span>(<span class="kw-2">&amp;</span><span class="ident">s</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.recv" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#659-665" title="goto source code">[src]</a></div><a href="#method.recv" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.recv" class="fnname">recv</a>&lt;T&gt;(&amp;mut self, r: &amp;'a <a class="struct" href="struct.Receiver.html" title="struct crossbeam_channel::Receiver">Receiver</a>&lt;T&gt;) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Adds a receive operation.</p>
<p>Returns the index of the added operation.</p>
<h5 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s</span>, <span class="ident">r</span>) <span class="op">=</span> <span class="ident">unbounded</span>::<span class="op">&lt;</span><span class="ident">i32</span><span class="op">&gt;</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">index</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r</span>);</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.remove" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#703-720" title="goto source code">[src]</a></div><a href="#method.remove" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.remove" class="fnname">remove</a>(&amp;mut self, index: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>)</h4></div></summary><div class="docblock"><p>Removes a previously added operation.</p>
<p>This is useful when an operation is selected because the channel got disconnected and we
want to try again to select a different operation instead.</p>
<p>If new operations are added after removing some, the indices of removed operations will not
be reused.</p>
<h5 id="panics" class="section-header"><a href="#panics">Panics</a></h5>
<p>An attempt to remove a non-existing or already removed operation will panic.</p>
<h5 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>::<span class="op">&lt;</span><span class="ident">i32</span><span class="op">&gt;</span>();
<span class="kw">let</span> (<span class="kw">_</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>::<span class="op">&lt;</span><span class="ident">i32</span><span class="op">&gt;</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="comment">// Both operations are initially ready, so a random one will be executed.</span>
<span class="kw">let</span> <span class="ident">oper</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">select</span>();
<span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">index</span>(), <span class="ident">oper2</span>);
<span class="macro">assert!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>).<span class="ident">is_err</span>());
<span class="ident">sel</span>.<span class="ident">remove</span>(<span class="ident">oper2</span>);
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="ident">oper</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">select</span>();
<span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">index</span>(), <span class="ident">oper1</span>);
<span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>), <span class="prelude-val">Ok</span>(<span class="number">10</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_select" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#760-762" title="goto source code">[src]</a></div><a href="#method.try_select" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_select" class="fnname">try_select</a>(&amp;mut self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="struct" href="struct.SelectedOperation.html" title="struct crossbeam_channel::SelectedOperation">SelectedOperation</a>&lt;'a&gt;, <a class="struct" href="struct.TrySelectError.html" title="struct crossbeam_channel::TrySelectError">TrySelectError</a>&gt;</h4></div></summary><div class="docblock"><p>Attempts to select one of the operations without blocking.</p>
<p>If an operation is ready, it is selected and returned. If multiple operations are ready at
the same time, a random one among them is selected. If none of the operations are ready, an
error is returned.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready
even when it will simply return an error because the channel is disconnected.</p>
<p>The selected operation must be completed with <a href="struct.SelectedOperation.html#method.send" title="SelectedOperation::send"><code>SelectedOperation::send</code></a>
or <a href="struct.SelectedOperation.html#method.recv" title="SelectedOperation::recv"><code>SelectedOperation::recv</code></a>.</p>
<h5 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="kw">let</span> (<span class="ident">s2</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
<span class="ident">s2</span>.<span class="ident">send</span>(<span class="number">20</span>).<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="comment">// Both operations are initially ready, so a random one will be executed.</span>
<span class="kw">let</span> <span class="ident">oper</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">try_select</span>();
<span class="kw">match</span> <span class="ident">oper</span> {
<span class="prelude-val">Err</span>(<span class="kw">_</span>) =&gt; <span class="macro">panic!</span>(<span class="string">&quot;both operations should be ready&quot;</span>),
<span class="prelude-val">Ok</span>(<span class="ident">oper</span>) =&gt; <span class="kw">match</span> <span class="ident">oper</span>.<span class="ident">index</span>() {
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper1</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>), <span class="prelude-val">Ok</span>(<span class="number">10</span>)),
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper2</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>), <span class="prelude-val">Ok</span>(<span class="number">20</span>)),
<span class="kw">_</span> =&gt; <span class="macro">unreachable!</span>(),
}
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.select" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#807-809" title="goto source code">[src]</a></div><a href="#method.select" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.select" class="fnname">select</a>(&amp;mut self) -&gt; <a class="struct" href="struct.SelectedOperation.html" title="struct crossbeam_channel::SelectedOperation">SelectedOperation</a>&lt;'a&gt;</h4></div></summary><div class="docblock"><p>Blocks until one of the operations becomes ready and selects it.</p>
<p>Once an operation becomes ready, it is selected and returned. If multiple operations are
ready at the same time, a random one among them is selected.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready
even when it will simply return an error because the channel is disconnected.</p>
<p>The selected operation must be completed with <a href="struct.SelectedOperation.html#method.send" title="SelectedOperation::send"><code>SelectedOperation::send</code></a>
or <a href="struct.SelectedOperation.html#method.recv" title="SelectedOperation::recv"><code>SelectedOperation::recv</code></a>.</p>
<h5 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h5>
<p>Panics if no operations have been added to <code>Select</code>.</p>
<h5 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::thread</span>;
<span class="kw">use</span> <span class="ident">std::time::Duration</span>;
<span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="kw">let</span> (<span class="ident">s2</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="ident">thread::sleep</span>(<span class="ident">Duration::from_secs</span>(<span class="number">1</span>));
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
});
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> <span class="ident">s2</span>.<span class="ident">send</span>(<span class="number">20</span>).<span class="ident">unwrap</span>());
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="comment">// The second operation will be selected because it becomes ready first.</span>
<span class="kw">let</span> <span class="ident">oper</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">select</span>();
<span class="kw">match</span> <span class="ident">oper</span>.<span class="ident">index</span>() {
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper1</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>), <span class="prelude-val">Ok</span>(<span class="number">10</span>)),
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper2</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>), <span class="prelude-val">Ok</span>(<span class="number">20</span>)),
<span class="kw">_</span> =&gt; <span class="macro">unreachable!</span>(),
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.select_timeout" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#854-859" title="goto source code">[src]</a></div><a href="#method.select_timeout" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.select_timeout" class="fnname">select_timeout</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;mut self, <br>&nbsp;&nbsp;&nbsp;&nbsp;timeout: <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a><br>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="struct" href="struct.SelectedOperation.html" title="struct crossbeam_channel::SelectedOperation">SelectedOperation</a>&lt;'a&gt;, <a class="struct" href="struct.SelectTimeoutError.html" title="struct crossbeam_channel::SelectTimeoutError">SelectTimeoutError</a>&gt;</h4></div></summary><div class="docblock"><p>Blocks for a limited time until one of the operations becomes ready and selects it.</p>
<p>If an operation becomes ready, it is selected and returned. If multiple operations are
ready at the same time, a random one among them is selected. If none of the operations
become ready for the specified duration, an error is returned.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready
even when it will simply return an error because the channel is disconnected.</p>
<p>The selected operation must be completed with <a href="struct.SelectedOperation.html#method.send" title="SelectedOperation::send"><code>SelectedOperation::send</code></a>
or <a href="struct.SelectedOperation.html#method.recv" title="SelectedOperation::recv"><code>SelectedOperation::recv</code></a>.</p>
<h5 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::thread</span>;
<span class="kw">use</span> <span class="ident">std::time::Duration</span>;
<span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="kw">let</span> (<span class="ident">s2</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="ident">thread::sleep</span>(<span class="ident">Duration::from_secs</span>(<span class="number">1</span>));
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
});
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> <span class="ident">s2</span>.<span class="ident">send</span>(<span class="number">20</span>).<span class="ident">unwrap</span>());
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="comment">// The second operation will be selected because it becomes ready first.</span>
<span class="kw">let</span> <span class="ident">oper</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">select_timeout</span>(<span class="ident">Duration::from_millis</span>(<span class="number">500</span>));
<span class="kw">match</span> <span class="ident">oper</span> {
<span class="prelude-val">Err</span>(<span class="kw">_</span>) =&gt; <span class="macro">panic!</span>(<span class="string">&quot;should not have timed out&quot;</span>),
<span class="prelude-val">Ok</span>(<span class="ident">oper</span>) =&gt; <span class="kw">match</span> <span class="ident">oper</span>.<span class="ident">index</span>() {
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper1</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>), <span class="prelude-val">Ok</span>(<span class="number">10</span>)),
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper2</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>), <span class="prelude-val">Ok</span>(<span class="number">20</span>)),
<span class="kw">_</span> =&gt; <span class="macro">unreachable!</span>(),
}
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.select_deadline" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#906-911" title="goto source code">[src]</a></div><a href="#method.select_deadline" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.select_deadline" class="fnname">select_deadline</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;mut self, <br>&nbsp;&nbsp;&nbsp;&nbsp;deadline: <a class="struct" href="https://doc.rust-lang.org/1.59.0/std/time/struct.Instant.html" title="struct std::time::Instant">Instant</a><br>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="struct" href="struct.SelectedOperation.html" title="struct crossbeam_channel::SelectedOperation">SelectedOperation</a>&lt;'a&gt;, <a class="struct" href="struct.SelectTimeoutError.html" title="struct crossbeam_channel::SelectTimeoutError">SelectTimeoutError</a>&gt;</h4></div></summary><div class="docblock"><p>Blocks until a given deadline, or until one of the operations becomes ready and selects it.</p>
<p>If an operation becomes ready, it is selected and returned. If multiple operations are
ready at the same time, a random one among them is selected. If none of the operations
become ready before the given deadline, an error is returned.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready
even when it will simply return an error because the channel is disconnected.</p>
<p>The selected operation must be completed with <a href="struct.SelectedOperation.html#method.send" title="SelectedOperation::send"><code>SelectedOperation::send</code></a>
or <a href="struct.SelectedOperation.html#method.recv" title="SelectedOperation::recv"><code>SelectedOperation::recv</code></a>.</p>
<h5 id="examples-8" class="section-header"><a href="#examples-8">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::thread</span>;
<span class="kw">use</span> <span class="ident">std::time</span>::{<span class="ident">Instant</span>, <span class="ident">Duration</span>};
<span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="kw">let</span> (<span class="ident">s2</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="ident">thread::sleep</span>(<span class="ident">Duration::from_secs</span>(<span class="number">1</span>));
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
});
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> <span class="ident">s2</span>.<span class="ident">send</span>(<span class="number">20</span>).<span class="ident">unwrap</span>());
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="kw">let</span> <span class="ident">deadline</span> <span class="op">=</span> <span class="ident">Instant::now</span>() <span class="op">+</span> <span class="ident">Duration::from_millis</span>(<span class="number">500</span>);
<span class="comment">// The second operation will be selected because it becomes ready first.</span>
<span class="kw">let</span> <span class="ident">oper</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">select_deadline</span>(<span class="ident">deadline</span>);
<span class="kw">match</span> <span class="ident">oper</span> {
<span class="prelude-val">Err</span>(<span class="kw">_</span>) =&gt; <span class="macro">panic!</span>(<span class="string">&quot;should not have timed out&quot;</span>),
<span class="prelude-val">Ok</span>(<span class="ident">oper</span>) =&gt; <span class="kw">match</span> <span class="ident">oper</span>.<span class="ident">index</span>() {
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper1</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>), <span class="prelude-val">Ok</span>(<span class="number">10</span>)),
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper2</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">oper</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>), <span class="prelude-val">Ok</span>(<span class="number">20</span>)),
<span class="kw">_</span> =&gt; <span class="macro">unreachable!</span>(),
}
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_ready" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#948-953" title="goto source code">[src]</a></div><a href="#method.try_ready" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_ready" class="fnname">try_ready</a>(&amp;mut self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>, <a class="struct" href="struct.TryReadyError.html" title="struct crossbeam_channel::TryReadyError">TryReadyError</a>&gt;</h4></div></summary><div class="docblock"><p>Attempts to find a ready operation without blocking.</p>
<p>If an operation is ready, its index is returned. If multiple operations are ready at the
same time, a random one among them is chosen. If none of the operations are ready, an error
is returned.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready
even when it will simply return an error because the channel is disconnected.</p>
<p>Note that this method might return with success spuriously, so it’s a good idea to always
double check if the operation is really ready.</p>
<h5 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="kw">let</span> (<span class="ident">s2</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
<span class="ident">s2</span>.<span class="ident">send</span>(<span class="number">20</span>).<span class="ident">unwrap</span>();
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="comment">// Both operations are initially ready, so a random one will be chosen.</span>
<span class="kw">match</span> <span class="ident">sel</span>.<span class="ident">try_ready</span>() {
<span class="prelude-val">Err</span>(<span class="kw">_</span>) =&gt; <span class="macro">panic!</span>(<span class="string">&quot;both operations should be ready&quot;</span>),
<span class="prelude-val">Ok</span>(<span class="ident">i</span>) <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper1</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">r1</span>.<span class="ident">try_recv</span>(), <span class="prelude-val">Ok</span>(<span class="number">10</span>)),
<span class="prelude-val">Ok</span>(<span class="ident">i</span>) <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper2</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">r2</span>.<span class="ident">try_recv</span>(), <span class="prelude-val">Ok</span>(<span class="number">20</span>)),
<span class="prelude-val">Ok</span>(<span class="kw">_</span>) =&gt; <span class="macro">unreachable!</span>(),
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ready" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#997-1003" title="goto source code">[src]</a></div><a href="#method.ready" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.ready" class="fnname">ready</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a></h4></div></summary><div class="docblock"><p>Blocks until one of the operations becomes ready.</p>
<p>Once an operation becomes ready, its index is returned. If multiple operations are ready at
the same time, a random one among them is chosen.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready
even when it will simply return an error because the channel is disconnected.</p>
<p>Note that this method might return with success spuriously, so it’s a good idea to always
double check if the operation is really ready.</p>
<h5 id="panics-2" class="section-header"><a href="#panics-2">Panics</a></h5>
<p>Panics if no operations have been added to <code>Select</code>.</p>
<h5 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::thread</span>;
<span class="kw">use</span> <span class="ident">std::time::Duration</span>;
<span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="kw">let</span> (<span class="ident">s2</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="ident">thread::sleep</span>(<span class="ident">Duration::from_secs</span>(<span class="number">1</span>));
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
});
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> <span class="ident">s2</span>.<span class="ident">send</span>(<span class="number">20</span>).<span class="ident">unwrap</span>());
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="comment">// The second operation will be selected because it becomes ready first.</span>
<span class="kw">match</span> <span class="ident">sel</span>.<span class="ident">ready</span>() {
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper1</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">r1</span>.<span class="ident">try_recv</span>(), <span class="prelude-val">Ok</span>(<span class="number">10</span>)),
<span class="ident">i</span> <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper2</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">r2</span>.<span class="ident">try_recv</span>(), <span class="prelude-val">Ok</span>(<span class="number">20</span>)),
<span class="kw">_</span> =&gt; <span class="macro">unreachable!</span>(),
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ready_timeout" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#1045-1047" title="goto source code">[src]</a></div><a href="#method.ready_timeout" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.ready_timeout" class="fnname">ready_timeout</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;mut self, <br>&nbsp;&nbsp;&nbsp;&nbsp;timeout: <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a><br>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>, <a class="struct" href="struct.ReadyTimeoutError.html" title="struct crossbeam_channel::ReadyTimeoutError">ReadyTimeoutError</a>&gt;</h4></div></summary><div class="docblock"><p>Blocks for a limited time until one of the operations becomes ready.</p>
<p>If an operation becomes ready, its index is returned. If multiple operations are ready at
the same time, a random one among them is chosen. If none of the operations become ready
for the specified duration, an error is returned.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready
even when it will simply return an error because the channel is disconnected.</p>
<p>Note that this method might return with success spuriously, so it’s a good idea to double
check if the operation is really ready.</p>
<h5 id="examples-11" class="section-header"><a href="#examples-11">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::thread</span>;
<span class="kw">use</span> <span class="ident">std::time::Duration</span>;
<span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="kw">let</span> (<span class="ident">s2</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="ident">thread::sleep</span>(<span class="ident">Duration::from_secs</span>(<span class="number">1</span>));
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
});
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> <span class="ident">s2</span>.<span class="ident">send</span>(<span class="number">20</span>).<span class="ident">unwrap</span>());
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="comment">// The second operation will be selected because it becomes ready first.</span>
<span class="kw">match</span> <span class="ident">sel</span>.<span class="ident">ready_timeout</span>(<span class="ident">Duration::from_millis</span>(<span class="number">500</span>)) {
<span class="prelude-val">Err</span>(<span class="kw">_</span>) =&gt; <span class="macro">panic!</span>(<span class="string">&quot;should not have timed out&quot;</span>),
<span class="prelude-val">Ok</span>(<span class="ident">i</span>) <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper1</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">r1</span>.<span class="ident">try_recv</span>(), <span class="prelude-val">Ok</span>(<span class="number">10</span>)),
<span class="prelude-val">Ok</span>(<span class="ident">i</span>) <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper2</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">r2</span>.<span class="ident">try_recv</span>(), <span class="prelude-val">Ok</span>(<span class="number">20</span>)),
<span class="prelude-val">Ok</span>(<span class="kw">_</span>) =&gt; <span class="macro">unreachable!</span>(),
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.ready_deadline" class="method has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#1091-1096" title="goto source code">[src]</a></div><a href="#method.ready_deadline" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.ready_deadline" class="fnname">ready_deadline</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;mut self, <br>&nbsp;&nbsp;&nbsp;&nbsp;deadline: <a class="struct" href="https://doc.rust-lang.org/1.59.0/std/time/struct.Instant.html" title="struct std::time::Instant">Instant</a><br>) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.usize.html">usize</a>, <a class="struct" href="struct.ReadyTimeoutError.html" title="struct crossbeam_channel::ReadyTimeoutError">ReadyTimeoutError</a>&gt;</h4></div></summary><div class="docblock"><p>Blocks until a given deadline, or until one of the operations becomes ready.</p>
<p>If an operation becomes ready, its index is returned. If multiple operations are ready at
the same time, a random one among them is chosen. If none of the operations become ready
before the deadline, an error is returned.</p>
<p>An operation is considered to be ready if it doesn’t have to block. Note that it is ready
even when it will simply return an error because the channel is disconnected.</p>
<p>Note that this method might return with success spuriously, so it’s a good idea to double
check if the operation is really ready.</p>
<h5 id="examples-12" class="section-header"><a href="#examples-12">Examples</a></h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">std::thread</span>;
<span class="kw">use</span> <span class="ident">std::time</span>::{<span class="ident">Duration</span>, <span class="ident">Instant</span>};
<span class="kw">use</span> <span class="ident">crossbeam_channel</span>::{<span class="ident">unbounded</span>, <span class="ident">Select</span>};
<span class="kw">let</span> <span class="ident">deadline</span> <span class="op">=</span> <span class="ident">Instant::now</span>() <span class="op">+</span> <span class="ident">Duration::from_millis</span>(<span class="number">500</span>);
<span class="kw">let</span> (<span class="ident">s1</span>, <span class="ident">r1</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="kw">let</span> (<span class="ident">s2</span>, <span class="ident">r2</span>) <span class="op">=</span> <span class="ident">unbounded</span>();
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="ident">thread::sleep</span>(<span class="ident">Duration::from_secs</span>(<span class="number">1</span>));
<span class="ident">s1</span>.<span class="ident">send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
});
<span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> <span class="ident">s2</span>.<span class="ident">send</span>(<span class="number">20</span>).<span class="ident">unwrap</span>());
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">sel</span> <span class="op">=</span> <span class="ident">Select::new</span>();
<span class="kw">let</span> <span class="ident">oper1</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r1</span>);
<span class="kw">let</span> <span class="ident">oper2</span> <span class="op">=</span> <span class="ident">sel</span>.<span class="ident">recv</span>(<span class="kw-2">&amp;</span><span class="ident">r2</span>);
<span class="comment">// The second operation will be selected because it becomes ready first.</span>
<span class="kw">match</span> <span class="ident">sel</span>.<span class="ident">ready_deadline</span>(<span class="ident">deadline</span>) {
<span class="prelude-val">Err</span>(<span class="kw">_</span>) =&gt; <span class="macro">panic!</span>(<span class="string">&quot;should not have timed out&quot;</span>),
<span class="prelude-val">Ok</span>(<span class="ident">i</span>) <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper1</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">r1</span>.<span class="ident">try_recv</span>(), <span class="prelude-val">Ok</span>(<span class="number">10</span>)),
<span class="prelude-val">Ok</span>(<span class="ident">i</span>) <span class="kw">if</span> <span class="ident">i</span> <span class="op">==</span> <span class="ident">oper2</span> =&gt; <span class="macro">assert_eq!</span>(<span class="ident">r2</span>.<span class="ident">try_recv</span>(), <span class="prelude-val">Ok</span>(<span class="number">20</span>)),
<span class="prelude-val">Ok</span>(<span class="kw">_</span>) =&gt; <span class="macro">unreachable!</span>(),
}</code></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" open><summary><div id="impl-Clone" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#1099-1106" title="goto source code">[src]</a></div><a href="#impl-Clone" class="anchor"></a><h3 class="code-header in-band">impl&lt;'a&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.clone" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#1100-1105" title="goto source code">[src]</a></div><a href="#method.clone" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/clone/trait.Clone.html#tymethod.clone" class="fnname">clone</a>(&amp;self) -&gt; <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h4></div></summary><div class='docblock'><p>Returns a copy of the value. <a href="https://doc.rust-lang.org/1.59.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"><div class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/clone.rs.html#130" title="goto source code">[src]</a></div><a href="#method.clone_from" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/clone/trait.Clone.html#method.clone_from" class="fnname">clone_from</a>(&amp;mut self, source: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;</a>Self)</h4></div></summary><div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/1.59.0/core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-Debug" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#1114-1118" title="goto source code">[src]</a></div><a href="#impl-Debug" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'_&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.fmt" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#1115-1117" title="goto source code">[src]</a></div><a href="#method.fmt" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/fmt/trait.Debug.html#tymethod.fmt" class="fnname">fmt</a>(&amp;self, f: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/fmt/struct.Formatter.html" title="struct core::fmt::Formatter">Formatter</a>&lt;'_&gt;) -&gt; <a class="type" href="https://doc.rust-lang.org/1.59.0/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></div></summary><div class='docblock'><p>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/1.59.0/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-Default" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#1108-1112" title="goto source code">[src]</a></div><a href="#impl-Default" class="anchor"></a><h3 class="code-header in-band">impl&lt;'a&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/default/trait.Default.html" title="trait core::default::Default">Default</a> for <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.default" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#1109-1111" title="goto source code">[src]</a></div><a href="#method.default" class="anchor"></a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.59.0/core/default/trait.Default.html#tymethod.default" class="fnname">default</a>() -&gt; <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h4></div></summary><div class='docblock'><p>Returns the “default value” for a type. <a href="https://doc.rust-lang.org/1.59.0/core/default/trait.Default.html#tymethod.default">Read more</a></p>
</div></details></div></details><div id="impl-Send" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#600" title="goto source code">[src]</a></div><a href="#impl-Send" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'_&gt;</h3></div><div id="impl-Sync" class="impl has-srclink"><div class="rightside"><a class="srclink" href="../src/crossbeam_channel/select.rs.html#601" title="goto source code">[src]</a></div><a href="#impl-Sync" class="anchor"></a><h3 class="code-header in-band">impl <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'_&gt;</h3></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"><div class="rightside"></div><a href="#impl-RefUnwindSafe" class="anchor"></a><h3 class="code-header in-band">impl&lt;'a&gt; !<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/panic/unwind_safe/trait.RefUnwindSafe.html" title="trait core::panic::unwind_safe::RefUnwindSafe">RefUnwindSafe</a> for <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h3></div><div id="impl-Unpin" class="impl has-srclink"><div class="rightside"></div><a href="#impl-Unpin" class="anchor"></a><h3 class="code-header in-band">impl&lt;'a&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Unpin.html" title="trait core::marker::Unpin">Unpin</a> for <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h3></div><div id="impl-UnwindSafe" class="impl has-srclink"><div class="rightside"></div><a href="#impl-UnwindSafe" class="anchor"></a><h3 class="code-header in-band">impl&lt;'a&gt; !<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/panic/unwind_safe/trait.UnwindSafe.html" title="trait core::panic::unwind_safe::UnwindSafe">UnwindSafe</a> for <a class="struct" href="struct.Select.html" title="struct crossbeam_channel::Select">Select</a>&lt;'a&gt;</h3></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" open><summary><div id="impl-Any" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/any.rs.html#132-136" title="goto source code">[src]</a></div><a href="#impl-Any" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></h3></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"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/any.rs.html#133" title="goto source code">[src]</a></div><a href="#method.type_id" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/any/trait.Any.html#tymethod.type_id" class="fnname">type_id</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/1.59.0/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4></div></summary><div class='docblock'><p>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/1.59.0/core/any/trait.Any.html#tymethod.type_id">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-Borrow%3CT%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/borrow.rs.html#209-214" title="goto source code">[src]</a></div><a href="#impl-Borrow%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;T&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.borrow" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/borrow.rs.html#211" title="goto source code">[src]</a></div><a href="#method.borrow" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.Borrow.html#tymethod.borrow" class="fnname">borrow</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;</a>T</h4></div></summary><div class='docblock'><p>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-BorrowMut%3CT%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/borrow.rs.html#218-222" title="goto source code">[src]</a></div><a href="#impl-BorrowMut%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a>&lt;T&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: ?<a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,&nbsp;</span></h3></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"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/borrow.rs.html#219" title="goto source code">[src]</a></div><a href="#method.borrow_mut" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fnname">borrow_mut</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;mut </a>T</h4></div></summary><div class='docblock'><p>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.59.0/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-From%3CT%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#550-554" title="goto source code">[src]</a></div><a href="#impl-From%3CT%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for T</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.from" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#551" title="goto source code">[src]</a></div><a href="#method.from" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.From.html#tymethod.from" class="fnname">from</a>(t: T) -&gt; T</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-Into%3CU%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#538-545" title="goto source code">[src]</a></div><a href="#impl-Into%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt;,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.into" class="method trait-impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#542" title="goto source code">[src]</a></div><a href="#method.into" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.Into.html#tymethod.into" class="fnname">into</a>(self) -&gt; U</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-ToOwned" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/alloc/borrow.rs.html#84-96" title="goto source code">[src]</a></div><a href="#impl-ToOwned" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Owned" class="type trait-impl has-srclink"><a href="#associatedtype.Owned" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.59.0/alloc/borrow/trait.ToOwned.html#associatedtype.Owned" class="associatedtype">Owned</a> = T</h4></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"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/alloc/borrow.rs.html#89" title="goto source code">[src]</a></div><a href="#method.to_owned" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/alloc/borrow/trait.ToOwned.html#tymethod.to_owned" class="fnname">to_owned</a>(&amp;self) -&gt; T</h4></div></summary><div class='docblock'><p>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/1.59.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"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/alloc/borrow.rs.html#93" title="goto source code">[src]</a></div><a href="#method.clone_into" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/alloc/borrow/trait.ToOwned.html#method.clone_into" class="fnname">clone_into</a>(&amp;self, target: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;mut </a>T)</h4></div></summary><div class="item-info"><div class="stab unstable"><span class="emoji">🔬</span> This is a nightly-only experimental API. (<code>toowned_clone_into</code>)</div></div><div class='docblock'><p>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/1.59.0/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-TryFrom%3CU%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#588-597" title="goto source code">[src]</a></div><a href="#impl-TryFrom%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;T&gt;,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error-1" class="type trait-impl has-srclink"><a href="#associatedtype.Error-1" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4></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"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#594" title="goto source code">[src]</a></div><a href="#method.try_from" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#tymethod.try_from" class="fnname">try_from</a>(value: U) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;T, &lt;T as <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details><details class="rustdoc-toggle implementors-toggle" open><summary><div id="impl-TryInto%3CU%3E" class="impl has-srclink"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#574-583" title="goto source code">[src]</a></div><a href="#impl-TryInto%3CU%3E" class="anchor"></a><h3 class="code-header in-band">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a>&lt;U&gt; for T <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;U: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;,&nbsp;</span></h3></div></summary><div class="impl-items"><details class="rustdoc-toggle" open><summary><div id="associatedtype.Error" class="type trait-impl has-srclink"><a href="#associatedtype.Error" class="anchor"></a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryInto.html#associatedtype.Error" class="associatedtype">Error</a> = &lt;U as <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4></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"><div class="rightside"><a class="srclink" href="https://doc.rust-lang.org/1.59.0/src/core/convert/mod.rs.html#580" title="goto source code">[src]</a></div><a href="#method.try_into" class="anchor"></a><h4 class="code-header">pub fn <a href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryInto.html#tymethod.try_into" class="fnname">try_into</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.59.0/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;U, &lt;U as <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;&gt;::<a class="associatedtype" href="https://doc.rust-lang.org/1.59.0/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></div></summary><div class='docblock'><p>Performs the conversion.</p>
</div></details></div></details></div></section><section id="search" class="content hidden"></section></div></main><div id="rustdoc-vars" data-root-path="../" data-current-crate="crossbeam_channel" data-themes="ayu,dark,light" data-resource-suffix="" data-rustdoc-version="1.59.0 (9d1b2106e 2022-02-23)" ></div>
</body></html>
Reference in New Issue View Git Blame Copy Permalink