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/tokio/sync/mpsc/struct.Sender.html

416 lines
73 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="Sends values to the associated `Receiver`."><meta name="keywords" content="rust, rustlang, rust-lang, Sender"><title>Sender in tokio::sync::mpsc - 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="../../../tokio/index.html"><div class="logo-container"><img class="rust-logo" src="../../../rust-logo.png" alt="logo"></div>
</a><h2 class="location">Struct Sender</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.blocking_send">blocking_send</a><a href="#method.capacity">capacity</a><a href="#method.closed">closed</a><a href="#method.is_closed">is_closed</a><a href="#method.reserve">reserve</a><a href="#method.reserve_owned">reserve_owned</a><a href="#method.same_channel">same_channel</a><a href="#method.send">send</a><a href="#method.send_timeout">send_timeout</a><a href="#method.try_reserve">try_reserve</a><a href="#method.try_reserve_owned">try_reserve_owned</a><a href="#method.try_send">try_send</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></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&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">tokio</a>::<wbr><a href="../index.html">sync</a>::<wbr><a href="index.html">mpsc</a></h2><div id="sidebar-vars" data-name="Sender" 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="../../../tokio/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">tokio</a>::<wbr><a href="../index.html">sync</a>::<wbr><a href="index.html">mpsc</a>::<wbr><a class="struct" href="#">Sender</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/tokio/sync/mpsc/bounded.rs.html#21-23" title="goto source code">[src]</a></span></h1><div class="docblock item-decl"><pre class="rust struct"><code>pub struct Sender&lt;T&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>Sends values to the associated <code>Receiver</code>.</p>
<p>Instances are created by the <a href="fn.channel.html"><code>channel</code></a> function.</p>
<p>To convert the <code>Sender</code> into a <code>Sink</code> or use it in a poll function, you can
use the <a href="https://docs.rs/tokio-util/0.6/tokio_util/sync/struct.PollSender.html"><code>PollSender</code></a> utility.</p>
</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/tokio/sync/mpsc/bounded.rs.html#369-991" title="goto source code">[src]</a></div><a href="#impl" class="anchor"></a><h3 class="code-header in-band">impl&lt;T&gt; <a class="struct" href="struct.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&gt;</h3></div></summary><div class="impl-items"><details class="rustdoc-toggle method-toggle" open><summary><div id="method.send" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#429-437" title="goto source code">[src]</a></div><a href="#method.send" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.send" class="fnname">send</a>(&amp;self, value: T) -&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.unit.html">()</a>, <a class="struct" href="error/struct.SendError.html" title="struct tokio::sync::mpsc::error::SendError">SendError</a>&lt;T&gt;&gt;</h4></div></summary><div class="docblock"><p>Sends a value, waiting until there is capacity.</p>
<p>A successful send occurs when it is determined that the other end of the
channel has not hung up already. An unsuccessful send would be one where
the corresponding receiver has already been closed. Note that a return
value of <code>Err</code> means that the data will never be received, but a return
value of <code>Ok</code> does not mean that the data will be received. It is
possible for the corresponding receiver to hang up immediately after
this function returns <code>Ok</code>.</p>
<h5 id="errors" class="section-header"><a href="#errors">Errors</a></h5>
<p>If the receive half of the channel is closed, either due to <a href="struct.Receiver.html#method.close"><code>close</code></a>
being called or the <a href="struct.Receiver.html"><code>Receiver</code></a> handle dropping, the function returns
an error. The error includes the value passed to <code>send</code>.</p>
<h5 id="cancel-safety" class="section-header"><a href="#cancel-safety">Cancel safety</a></h5>
<p>If <code>send</code> is used as the event in a <a href="../../macro.select.html"><code>tokio::select!</code></a>
statement and some other branch completes first, then it is guaranteed
that the message was not sent.</p>
<p>This channel uses a queue to ensure that calls to <code>send</code> and <code>reserve</code>
complete in the order they were requested. Cancelling a call to
<code>send</code> makes you lose your place in the queue.</p>
<h5 id="examples" class="section-header"><a href="#examples">Examples</a></h5>
<p>In the following example, each call to <code>send</code> will block until the
previously sent value was received.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>(<span class="number">1</span>);
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="kw">for</span> <span class="ident">i</span> <span class="kw">in</span> <span class="number">0</span>..<span class="number">10</span> {
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Err</span>(<span class="kw">_</span>) <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">send</span>(<span class="ident">i</span>).<span class="kw">await</span> {
<span class="macro">println!</span>(<span class="string">&quot;receiver dropped&quot;</span>);
<span class="kw">return</span>;
}
}
});
<span class="kw">while</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">i</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span> {
<span class="macro">println!</span>(<span class="string">&quot;got = {}&quot;</span>, <span class="ident">i</span>);
}
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.closed" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#475-477" title="goto source code">[src]</a></div><a href="#method.closed" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.closed" class="fnname">closed</a>(&amp;self)</h4></div></summary><div class="docblock"><p>Completes when the receiver has dropped.</p>
<p>This allows the producers to get notified when interest in the produced
values is canceled and immediately stop doing work.</p>
<h5 id="cancel-safety-1" class="section-header"><a href="#cancel-safety-1">Cancel safety</a></h5>
<p>This method is cancel safe. Once the channel is closed, it stays closed
forever and all future calls to <code>closed</code> will return immediately.</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">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx1</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>::<span class="op">&lt;</span>()<span class="op">&gt;</span>(<span class="number">1</span>);
<span class="kw">let</span> <span class="ident">tx2</span> <span class="op">=</span> <span class="ident">tx1</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">tx3</span> <span class="op">=</span> <span class="ident">tx1</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">tx4</span> <span class="op">=</span> <span class="ident">tx1</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">tx5</span> <span class="op">=</span> <span class="ident">tx1</span>.<span class="ident">clone</span>();
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="ident">drop</span>(<span class="ident">rx</span>);
});
<span class="macro">futures::join!</span>(
<span class="ident">tx1</span>.<span class="ident">closed</span>(),
<span class="ident">tx2</span>.<span class="ident">closed</span>(),
<span class="ident">tx3</span>.<span class="ident">closed</span>(),
<span class="ident">tx4</span>.<span class="ident">closed</span>(),
<span class="ident">tx5</span>.<span class="ident">closed</span>()
);
<span class="macro">println!</span>(<span class="string">&quot;Receiver dropped&quot;</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_send" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#537-547" title="goto source code">[src]</a></div><a href="#method.try_send" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_send" class="fnname">try_send</a>(&amp;self, message: T) -&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.unit.html">()</a>, <a class="enum" href="error/enum.TrySendError.html" title="enum tokio::sync::mpsc::error::TrySendError">TrySendError</a>&lt;T&gt;&gt;</h4></div></summary><div class="docblock"><p>Attempts to immediately send a message on this <code>Sender</code></p>
<p>This method differs from <a href="struct.Sender.html#method.send"><code>send</code></a> by returning immediately if the channel’s
buffer is full or no receiver is waiting to acquire some data. Compared
with <a href="struct.Sender.html#method.send"><code>send</code></a>, this function has two failure cases instead of one (one for
disconnection, one for a full buffer).</p>
<h5 id="errors-1" class="section-header"><a href="#errors-1">Errors</a></h5>
<p>If the channel capacity has been reached, i.e., the channel has <code>n</code>
buffered values where <code>n</code> is the argument passed to <a href="fn.channel.html"><code>channel</code></a>, then an
error is returned.</p>
<p>If the receive half of the channel is closed, either due to <a href="struct.Receiver.html#method.close"><code>close</code></a>
being called or the <a href="struct.Receiver.html" title="Receiver"><code>Receiver</code></a> handle dropping, the function returns
an error. The error includes the value passed to <code>send</code>.</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">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="comment">// Create a channel with buffer size 1</span>
<span class="kw">let</span> (<span class="ident">tx1</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>(<span class="number">1</span>);
<span class="kw">let</span> <span class="ident">tx2</span> <span class="op">=</span> <span class="ident">tx1</span>.<span class="ident">clone</span>();
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="ident">tx1</span>.<span class="ident">send</span>(<span class="number">1</span>).<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="ident">tx1</span>.<span class="ident">send</span>(<span class="number">2</span>).<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="comment">// task waits until the receiver receives a value.</span>
});
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="comment">// This will return an error and send</span>
<span class="comment">// no message if the buffer is full</span>
<span class="kw">let</span> <span class="kw">_</span> <span class="op">=</span> <span class="ident">tx2</span>.<span class="ident">try_send</span>(<span class="number">3</span>);
});
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">msg</span>;
<span class="ident">msg</span> <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="macro">println!</span>(<span class="string">&quot;message {} received&quot;</span>, <span class="ident">msg</span>);
<span class="ident">msg</span> <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="macro">println!</span>(<span class="string">&quot;message {} received&quot;</span>, <span class="ident">msg</span>);
<span class="comment">// Third message may have never been sent</span>
<span class="kw">match</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span> {
<span class="prelude-val">Some</span>(<span class="ident">msg</span>) =&gt; <span class="macro">println!</span>(<span class="string">&quot;message {} received&quot;</span>, <span class="ident">msg</span>),
<span class="prelude-val">None</span> =&gt; <span class="macro">println!</span>(<span class="string">&quot;the third message was never sent&quot;</span>),
}
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.send_timeout" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#601-618" title="goto source code">[src]</a></div><a href="#method.send_timeout" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.send_timeout" class="fnname">send_timeout</a>(<br>&nbsp;&nbsp;&nbsp;&nbsp;&amp;self, <br>&nbsp;&nbsp;&nbsp;&nbsp;value: T, <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.unit.html">()</a>, <a class="enum" href="error/enum.SendTimeoutError.html" title="enum tokio::sync::mpsc::error::SendTimeoutError">SendTimeoutError</a>&lt;T&gt;&gt;</h4></div></summary><div class="docblock"><p>Sends a value, waiting until there is capacity, but only for a limited time.</p>
<p>Shares the same success and error conditions as <a href="struct.Sender.html#method.send"><code>send</code></a>, adding one more
condition for an unsuccessful send, which is when the provided timeout has
elapsed, and there is no capacity available.</p>
<h5 id="errors-2" class="section-header"><a href="#errors-2">Errors</a></h5>
<p>If the receive half of the channel is closed, either due to <a href="struct.Receiver.html#method.close"><code>close</code></a>
being called or the <a href="struct.Receiver.html"><code>Receiver</code></a> having been dropped,
the function returns an error. The error includes the value passed to <code>send</code>.</p>
<h5 id="panics" class="section-header"><a href="#panics">Panics</a></h5>
<p>This function panics if it is called outside the context of a Tokio
runtime <a href="../../runtime/struct.Builder.html#method.enable_time">with time enabled</a>.</p>
<h5 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h5>
<p>In the following example, each call to <code>send_timeout</code> will block until the
previously sent value was received, unless the timeout has elapsed.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::sync::mpsc</span>;
<span class="kw">use</span> <span class="ident">tokio::time</span>::{<span class="ident">sleep</span>, <span class="ident">Duration</span>};
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>(<span class="number">1</span>);
<span class="ident">tokio::spawn</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="kw">for</span> <span class="ident">i</span> <span class="kw">in</span> <span class="number">0</span>..<span class="number">10</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">tx</span>.<span class="ident">send_timeout</span>(<span class="ident">i</span>, <span class="ident">Duration::from_millis</span>(<span class="number">100</span>)).<span class="kw">await</span> {
<span class="macro">println!</span>(<span class="string">&quot;send error: #{:?}&quot;</span>, <span class="ident">e</span>);
<span class="kw">return</span>;
}
}
});
<span class="kw">while</span> <span class="kw">let</span> <span class="prelude-val">Some</span>(<span class="ident">i</span>) <span class="op">=</span> <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span> {
<span class="macro">println!</span>(<span class="string">&quot;got = {}&quot;</span>, <span class="ident">i</span>);
<span class="ident">sleep</span>(<span class="ident">Duration::from_millis</span>(<span class="number">200</span>)).<span class="kw">await</span>;
}
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.blocking_send" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#654-656" title="goto source code">[src]</a></div><a href="#method.blocking_send" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.blocking_send" class="fnname">blocking_send</a>(&amp;self, value: T) -&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.unit.html">()</a>, <a class="struct" href="error/struct.SendError.html" title="struct tokio::sync::mpsc::error::SendError">SendError</a>&lt;T&gt;&gt;</h4></div></summary><div class="docblock"><p>Blocking send to call outside of asynchronous contexts.</p>
<p>This method is intended for use cases where you are sending from
synchronous code to asynchronous code, and will work even if the
receiver is not using <a href="struct.Receiver.html#method.blocking_recv"><code>blocking_recv</code></a> to receive the message.</p>
<h5 id="panics-1" class="section-header"><a href="#panics-1">Panics</a></h5>
<p>This function panics if called within an asynchronous execution
context.</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">std::thread</span>;
<span class="kw">use</span> <span class="ident">tokio::runtime::Runtime</span>;
<span class="kw">use</span> <span class="ident">tokio::sync::mpsc</span>;
<span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>::<span class="op">&lt;</span><span class="ident">u8</span><span class="op">&gt;</span>(<span class="number">1</span>);
<span class="kw">let</span> <span class="ident">sync_code</span> <span class="op">=</span> <span class="ident">thread::spawn</span>(<span class="kw">move</span> <span class="op">|</span><span class="op">|</span> {
<span class="ident">tx</span>.<span class="ident">blocking_send</span>(<span class="number">10</span>).<span class="ident">unwrap</span>();
});
<span class="ident">Runtime::new</span>().<span class="ident">unwrap</span>().<span class="ident">block_on</span>(<span class="kw">async</span> <span class="kw">move</span> {
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(<span class="number">10</span>), <span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>);
});
<span class="ident">sync_code</span>.<span class="ident">join</span>().<span class="ident">unwrap</span>()
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.is_closed" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#676-678" title="goto source code">[src]</a></div><a href="#method.is_closed" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.is_closed" class="fnname">is_closed</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a></h4></div></summary><div class="docblock"><p>Checks if the channel has been closed. This happens when the
<a href="struct.Receiver.html"><code>Receiver</code></a> is dropped, or when the <a href="struct.Receiver.html#method.close"><code>Receiver::close</code></a> method is
called.</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">tokio::sync::mpsc::channel</span>::<span class="op">&lt;</span>()<span class="op">&gt;</span>(<span class="number">42</span>);
<span class="macro">assert!</span>(<span class="op">!</span><span class="ident">tx</span>.<span class="ident">is_closed</span>());
<span class="kw">let</span> <span class="ident">tx2</span> <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">clone</span>();
<span class="macro">assert!</span>(<span class="op">!</span><span class="ident">tx2</span>.<span class="ident">is_closed</span>());
<span class="ident">drop</span>(<span class="ident">rx</span>);
<span class="macro">assert!</span>(<span class="ident">tx</span>.<span class="ident">is_closed</span>());
<span class="macro">assert!</span>(<span class="ident">tx2</span>.<span class="ident">is_closed</span>());</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.reserve" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#724-727" title="goto source code">[src]</a></div><a href="#method.reserve" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.reserve" class="fnname">reserve</a>(&amp;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.Permit.html" title="struct tokio::sync::mpsc::Permit">Permit</a>&lt;'_, T&gt;, <a class="struct" href="error/struct.SendError.html" title="struct tokio::sync::mpsc::error::SendError">SendError</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;&gt;</h4></div></summary><div class="docblock"><p>Waits for channel capacity. Once capacity to send one message is
available, it is reserved for the caller.</p>
<p>If the channel is full, the function waits for the number of unreceived
messages to become less than the channel capacity. Capacity to send one
message is reserved for the caller. A <a href="struct.Permit.html"><code>Permit</code></a> is returned to track
the reserved capacity. The <a href="struct.Permit.html#method.send"><code>send</code></a> function on <a href="struct.Permit.html"><code>Permit</code></a> consumes the
reserved capacity.</p>
<p>Dropping <a href="struct.Permit.html"><code>Permit</code></a> without sending a message releases the capacity back
to the channel.</p>
<h5 id="cancel-safety-2" class="section-header"><a href="#cancel-safety-2">Cancel safety</a></h5>
<p>This channel uses a queue to ensure that calls to <code>send</code> and <code>reserve</code>
complete in the order they were requested. Cancelling a call to
<code>reserve</code> makes you lose your place in the queue.</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">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>(<span class="number">1</span>);
<span class="comment">// Reserve capacity</span>
<span class="kw">let</span> <span class="ident">permit</span> <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">reserve</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="comment">// Trying to send directly on the `tx` will fail due to no</span>
<span class="comment">// available capacity.</span>
<span class="macro">assert!</span>(<span class="ident">tx</span>.<span class="ident">try_send</span>(<span class="number">123</span>).<span class="ident">is_err</span>());
<span class="comment">// Sending on the permit succeeds</span>
<span class="ident">permit</span>.<span class="ident">send</span>(<span class="number">456</span>);
<span class="comment">// The value sent on the permit is received</span>
<span class="macro">assert_eq!</span>(<span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>(), <span class="number">456</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.reserve_owned" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#809-814" title="goto source code">[src]</a></div><a href="#method.reserve_owned" class="anchor"></a><h4 class="code-header">pub async fn <a href="#method.reserve_owned" class="fnname">reserve_owned</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;<a class="struct" href="struct.OwnedPermit.html" title="struct tokio::sync::mpsc::OwnedPermit">OwnedPermit</a>&lt;T&gt;, <a class="struct" href="error/struct.SendError.html" title="struct tokio::sync::mpsc::error::SendError">SendError</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;&gt;</h4></div></summary><div class="docblock"><p>Waits for channel capacity, moving the <code>Sender</code> and returning an owned
permit. Once capacity to send one message is available, it is reserved
for the caller.</p>
<p>This moves the sender <em>by value</em>, and returns an owned permit that can
be used to send a message into the channel. Unlike <a href="struct.Sender.html#method.reserve"><code>Sender::reserve</code></a>,
this method may be used in cases where the permit must be valid for the
<code>'static</code> lifetime. <code>Sender</code>s may be cloned cheaply (<code>Sender::clone</code> is
essentially a reference count increment, comparable to <a href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html#method.clone"><code>Arc::clone</code></a>),
so when multiple <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a>s are needed or the <code>Sender</code> cannot be
moved, it can be cloned prior to calling <code>reserve_owned</code>.</p>
<p>If the channel is full, the function waits for the number of unreceived
messages to become less than the channel capacity. Capacity to send one
message is reserved for the caller. An <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a> is returned to
track the reserved capacity. The <a href="struct.OwnedPermit.html#method.send"><code>send</code></a> function on <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a>
consumes the reserved capacity.</p>
<p>Dropping the <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a> without sending a message releases the
capacity back to the channel.</p>
<h5 id="cancel-safety-3" class="section-header"><a href="#cancel-safety-3">Cancel safety</a></h5>
<p>This channel uses a queue to ensure that calls to <code>send</code> and <code>reserve</code>
complete in the order they were requested. Cancelling a call to
<code>reserve_owned</code> makes you lose your place in the queue.</p>
<h5 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h5>
<p>Sending a message using an <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a>:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>(<span class="number">1</span>);
<span class="comment">// Reserve capacity, moving the sender.</span>
<span class="kw">let</span> <span class="ident">permit</span> <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">reserve_owned</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="comment">// Send a message, consuming the permit and returning</span>
<span class="comment">// the moved sender.</span>
<span class="kw">let</span> <span class="ident">tx</span> <span class="op">=</span> <span class="ident">permit</span>.<span class="ident">send</span>(<span class="number">123</span>);
<span class="comment">// The value sent on the permit is received.</span>
<span class="macro">assert_eq!</span>(<span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>(), <span class="number">123</span>);
<span class="comment">// The sender can now be used again.</span>
<span class="ident">tx</span>.<span class="ident">send</span>(<span class="number">456</span>).<span class="kw">await</span>.<span class="ident">unwrap</span>();
}</code></pre></div>
<p>When multiple <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a>s are needed, or the sender cannot be moved
by value, it can be inexpensively cloned before calling <code>reserve_owned</code>:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use</span> <span class="ident">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>(<span class="number">1</span>);
<span class="comment">// Clone the sender and reserve capacity.</span>
<span class="kw">let</span> <span class="ident">permit</span> <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">clone</span>().<span class="ident">reserve_owned</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="comment">// Trying to send directly on the `tx` will fail due to no</span>
<span class="comment">// available capacity.</span>
<span class="macro">assert!</span>(<span class="ident">tx</span>.<span class="ident">try_send</span>(<span class="number">123</span>).<span class="ident">is_err</span>());
<span class="comment">// Sending on the permit succeeds.</span>
<span class="ident">permit</span>.<span class="ident">send</span>(<span class="number">456</span>);
<span class="comment">// The value sent on the permit is received</span>
<span class="macro">assert_eq!</span>(<span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>(), <span class="number">456</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_reserve" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#866-874" title="goto source code">[src]</a></div><a href="#method.try_reserve" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_reserve" class="fnname">try_reserve</a>(&amp;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.Permit.html" title="struct tokio::sync::mpsc::Permit">Permit</a>&lt;'_, T&gt;, <a class="enum" href="error/enum.TrySendError.html" title="enum tokio::sync::mpsc::error::TrySendError">TrySendError</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.unit.html">()</a>&gt;&gt;</h4></div></summary><div class="docblock"><p>Tries to acquire a slot in the channel without waiting for the slot to become
available.</p>
<p>If the channel is full this function will return <a href="error/enum.TrySendError.html" title="TrySendError"><code>TrySendError</code></a>, otherwise
if there is a slot available it will return a <a href="struct.Permit.html"><code>Permit</code></a> that will then allow you
to <a href="struct.Permit.html#method.send"><code>send</code></a> on the channel with a guaranteed slot. This function is similar to
<a href="struct.Sender.html#method.reserve"><code>reserve</code></a> except it does not await for the slot to become available.</p>
<p>Dropping <a href="struct.Permit.html"><code>Permit</code></a> without sending a message releases the capacity back
to the channel.</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">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>(<span class="number">1</span>);
<span class="comment">// Reserve capacity</span>
<span class="kw">let</span> <span class="ident">permit</span> <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">try_reserve</span>().<span class="ident">unwrap</span>();
<span class="comment">// Trying to send directly on the `tx` will fail due to no</span>
<span class="comment">// available capacity.</span>
<span class="macro">assert!</span>(<span class="ident">tx</span>.<span class="ident">try_send</span>(<span class="number">123</span>).<span class="ident">is_err</span>());
<span class="comment">// Trying to reserve an additional slot on the `tx` will</span>
<span class="comment">// fail because there is no capacity.</span>
<span class="macro">assert!</span>(<span class="ident">tx</span>.<span class="ident">try_reserve</span>().<span class="ident">is_err</span>());
<span class="comment">// Sending on the permit succeeds</span>
<span class="ident">permit</span>.<span class="ident">send</span>(<span class="number">456</span>);
<span class="comment">// The value sent on the permit is received</span>
<span class="macro">assert_eq!</span>(<span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>(), <span class="number">456</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.try_reserve_owned" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#931-941" title="goto source code">[src]</a></div><a href="#method.try_reserve_owned" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.try_reserve_owned" class="fnname">try_reserve_owned</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;<a class="struct" href="struct.OwnedPermit.html" title="struct tokio::sync::mpsc::OwnedPermit">OwnedPermit</a>&lt;T&gt;, <a class="enum" href="error/enum.TrySendError.html" title="enum tokio::sync::mpsc::error::TrySendError">TrySendError</a>&lt;Self&gt;&gt;</h4></div></summary><div class="docblock"><p>Tries to acquire a slot in the channel without waiting for the slot to become
available, returning an owned permit.</p>
<p>This moves the sender <em>by value</em>, and returns an owned permit that can
be used to send a message into the channel. Unlike <a href="struct.Sender.html#method.try_reserve" title="Sender::try_reserve"><code>Sender::try_reserve</code></a>,
this method may be used in cases where the permit must be valid for the
<code>'static</code> lifetime. <code>Sender</code>s may be cloned cheaply (<code>Sender::clone</code> is
essentially a reference count increment, comparable to <a href="https://doc.rust-lang.org/1.59.0/alloc/sync/struct.Arc.html#method.clone"><code>Arc::clone</code></a>),
so when multiple <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a>s are needed or the <code>Sender</code> cannot be
moved, it can be cloned prior to calling <code>try_reserve_owned</code>.</p>
<p>If the channel is full this function will return a <a href="error/enum.TrySendError.html" title="TrySendError"><code>TrySendError</code></a>.
Since the sender is taken by value, the <code>TrySendError</code> returned in this
case contains the sender, so that it may be used again. Otherwise, if
there is a slot available, this method will return an <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a>
that can then be used to <a href="struct.OwnedPermit.html#method.send"><code>send</code></a> on the channel with a guaranteed slot.
This function is similar to <a href="struct.Sender.html#method.reserve_owned"><code>reserve_owned</code></a> except it does not await
for the slot to become available.</p>
<p>Dropping the <a href="struct.OwnedPermit.html"><code>OwnedPermit</code></a> without sending a message releases the capacity back
to the channel.</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">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>(<span class="number">1</span>);
<span class="comment">// Reserve capacity</span>
<span class="kw">let</span> <span class="ident">permit</span> <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">clone</span>().<span class="ident">try_reserve_owned</span>().<span class="ident">unwrap</span>();
<span class="comment">// Trying to send directly on the `tx` will fail due to no</span>
<span class="comment">// available capacity.</span>
<span class="macro">assert!</span>(<span class="ident">tx</span>.<span class="ident">try_send</span>(<span class="number">123</span>).<span class="ident">is_err</span>());
<span class="comment">// Trying to reserve an additional slot on the `tx` will</span>
<span class="comment">// fail because there is no capacity.</span>
<span class="macro">assert!</span>(<span class="ident">tx</span>.<span class="ident">try_reserve</span>().<span class="ident">is_err</span>());
<span class="comment">// Sending on the permit succeeds</span>
<span class="ident">permit</span>.<span class="ident">send</span>(<span class="number">456</span>);
<span class="comment">// The value sent on the permit is received</span>
<span class="macro">assert_eq!</span>(<span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>(), <span class="number">456</span>);
}</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.same_channel" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#955-957" title="goto source code">[src]</a></div><a href="#method.same_channel" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.same_channel" class="fnname">same_channel</a>(&amp;self, other: <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.reference.html">&amp;</a>Self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.59.0/std/primitive.bool.html">bool</a></h4></div></summary><div class="docblock"><p>Returns <code>true</code> if senders belong to the same channel.</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">let</span> (<span class="ident">tx</span>, <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">tokio::sync::mpsc::channel</span>::<span class="op">&lt;</span>()<span class="op">&gt;</span>(<span class="number">1</span>);
<span class="kw">let</span> <span class="ident">tx2</span> <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">clone</span>();
<span class="macro">assert!</span>(<span class="ident">tx</span>.<span class="ident">same_channel</span>(<span class="kw-2">&amp;</span><span class="ident">tx2</span>));
<span class="kw">let</span> (<span class="ident">tx3</span>, <span class="ident">rx3</span>) <span class="op">=</span> <span class="ident">tokio::sync::mpsc::channel</span>::<span class="op">&lt;</span>()<span class="op">&gt;</span>(<span class="number">1</span>);
<span class="macro">assert!</span>(<span class="op">!</span><span class="ident">tx3</span>.<span class="ident">same_channel</span>(<span class="kw-2">&amp;</span><span class="ident">tx2</span>));</code></pre></div>
</div></details><details class="rustdoc-toggle method-toggle" open><summary><div id="method.capacity" class="method has-srclink"><div class="rightside"><a class="srclink" href="../../../src/tokio/sync/mpsc/bounded.rs.html#988-990" title="goto source code">[src]</a></div><a href="#method.capacity" class="anchor"></a><h4 class="code-header">pub fn <a href="#method.capacity" class="fnname">capacity</a>(&amp;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>Returns the current capacity of the channel.</p>
<p>The capacity goes down when sending a value by calling <a href="struct.Sender.html#method.send"><code>send</code></a> or by reserving capacity
with <a href="struct.Sender.html#method.reserve"><code>reserve</code></a>. The capacity goes up when values are received by the <a href="struct.Receiver.html" title="Receiver"><code>Receiver</code></a>.</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">tokio::sync::mpsc</span>;
<span class="attribute">#[<span class="ident">tokio::main</span>]</span>
<span class="kw">async</span> <span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> (<span class="ident">tx</span>, <span class="kw-2">mut</span> <span class="ident">rx</span>) <span class="op">=</span> <span class="ident">mpsc::channel</span>::<span class="op">&lt;</span>()<span class="op">&gt;</span>(<span class="number">5</span>);
<span class="macro">assert_eq!</span>(<span class="ident">tx</span>.<span class="ident">capacity</span>(), <span class="number">5</span>);
<span class="comment">// Making a reservation drops the capacity by one.</span>
<span class="kw">let</span> <span class="ident">permit</span> <span class="op">=</span> <span class="ident">tx</span>.<span class="ident">reserve</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="macro">assert_eq!</span>(<span class="ident">tx</span>.<span class="ident">capacity</span>(), <span class="number">4</span>);
<span class="comment">// Sending and receiving a value increases the capacity by one.</span>
<span class="ident">permit</span>.<span class="ident">send</span>(());
<span class="ident">rx</span>.<span class="ident">recv</span>().<span class="kw">await</span>.<span class="ident">unwrap</span>();
<span class="macro">assert_eq!</span>(<span class="ident">tx</span>.<span class="ident">capacity</span>(), <span class="number">5</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/tokio/sync/mpsc/bounded.rs.html#993-999" title="goto source code">[src]</a></div><a href="#impl-Clone" 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/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="struct.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&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/tokio/sync/mpsc/bounded.rs.html#994-998" 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; Self</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/tokio/sync/mpsc/bounded.rs.html#1001-1007" title="goto source code">[src]</a></div><a href="#impl-Debug" 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/fmt/trait.Debug.html" title="trait core::fmt::Debug">Debug</a> for <a class="struct" href="struct.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&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/tokio/sync/mpsc/bounded.rs.html#1002-1006" 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, fmt: &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></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;T&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.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&gt;</h3></div><div id="impl-Send" class="impl has-srclink"><div class="rightside"></div><a href="#impl-Send" 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/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="struct.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,&nbsp;</span></h3></div><div id="impl-Sync" class="impl has-srclink"><div class="rightside"></div><a href="#impl-Sync" 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/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="struct.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&gt; <span class="where fmt-newline">where<br>&nbsp;&nbsp;&nbsp;&nbsp;T: <a class="trait" href="https://doc.rust-lang.org/1.59.0/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,&nbsp;</span></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;T&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.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&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;T&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.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&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="tokio" 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