hobokenchicken/GopherGate
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
027aa0a5bd93bd710c2992ea0d08ca1f9417c006
GopherGate/target/doc/tokio/sync/mpsc/struct.Sender.html
hobokenchicken 49701c85ad Adding large folders
2026-02-26 12:00:21 -05:00

500 lines
77 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`."><title>Sender in tokio::sync::mpsc - Rust</title><script>if(window.location.protocol!=="file:")document.head.insertAdjacentHTML("beforeend","SourceSerif4-Regular-6b053e98.ttf.woff2,FiraSans-Italic-81dc35de.woff2,FiraSans-Regular-0fe48ade.woff2,FiraSans-MediumItalic-ccf7e434.woff2,FiraSans-Medium-e1aa3f0a.woff2,SourceCodePro-Regular-8badfe75.ttf.woff2,SourceCodePro-Semibold-aa29a496.ttf.woff2".split(",").map(f=>`<link rel="preload" as="font" type="font/woff2"href="../../../static.files/${f}">`).join(""))</script><link rel="stylesheet" href="../../../static.files/normalize-9960930a.css"><link rel="stylesheet" href="../../../static.files/rustdoc-ca0dd0c4.css"><meta name="rustdoc-vars" data-root-path="../../../" data-static-root-path="../../../static.files/" data-current-crate="tokio" data-themes="" data-resource-suffix="" data-rustdoc-version="1.93.1 (01f6ddf75 2026-02-11) (Arch Linux rust 1:1.93.1-1)" data-channel="1.93.1" data-search-js="search-9e2438ea.js" data-stringdex-js="stringdex-a3946164.js" data-settings-js="settings-c38705f0.js" ><script src="../../../static.files/storage-e2aeef58.js"></script><script defer src="sidebar-items.js"></script><script defer src="../../../static.files/main-a410ff4d.js"></script><noscript><link rel="stylesheet" href="../../../static.files/noscript-263c88ec.css"></noscript><link rel="alternate icon" type="image/png" href="../../../static.files/favicon-32x32-eab170b8.png"><link rel="icon" type="image/svg+xml" href="../../../static.files/favicon-044be391.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]--><rustdoc-topbar><h2><a href="#">Sender</a></h2></rustdoc-topbar><nav class="sidebar"><div class="sidebar-crate"><h2><a href="../../../tokio/index.html">tokio</a><span class="version">1.49.0</span></h2></div><div class="sidebar-elems"><section id="rustdoc-toc"><h2 class="location"><a href="#">Sender</a></h2><h3><a href="#implementations">Methods</a></h3><ul class="block method"><li><a href="#method.blocking_send" title="blocking_send">blocking_send</a></li><li><a href="#method.capacity" title="capacity">capacity</a></li><li><a href="#method.closed" title="closed">closed</a></li><li><a href="#method.downgrade" title="downgrade">downgrade</a></li><li><a href="#method.is_closed" title="is_closed">is_closed</a></li><li><a href="#method.max_capacity" title="max_capacity">max_capacity</a></li><li><a href="#method.reserve" title="reserve">reserve</a></li><li><a href="#method.reserve_many" title="reserve_many">reserve_many</a></li><li><a href="#method.reserve_owned" title="reserve_owned">reserve_owned</a></li><li><a href="#method.same_channel" title="same_channel">same_channel</a></li><li><a href="#method.send" title="send">send</a></li><li><a href="#method.send_timeout" title="send_timeout">send_timeout</a></li><li><a href="#method.strong_count" title="strong_count">strong_count</a></li><li><a href="#method.try_reserve" title="try_reserve">try_reserve</a></li><li><a href="#method.try_reserve_many" title="try_reserve_many">try_reserve_many</a></li><li><a href="#method.try_reserve_owned" title="try_reserve_owned">try_reserve_owned</a></li><li><a href="#method.try_send" title="try_send">try_send</a></li><li><a href="#method.weak_count" title="weak_count">weak_count</a></li></ul><h3><a href="#trait-implementations">Trait Implementations</a></h3><ul class="block trait-implementation"><li><a href="#impl-Clone-for-Sender%3CT%3E" title="Clone">Clone</a></li><li><a href="#impl-Debug-for-Sender%3CT%3E" title="Debug">Debug</a></li></ul><h3><a href="#synthetic-implementations">Auto Trait Implementations</a></h3><ul class="block synthetic-implementation"><li><a href="#impl-Freeze-for-Sender%3CT%3E" title="Freeze">Freeze</a></li><li><a href="#impl-RefUnwindSafe-for-Sender%3CT%3E" title="RefUnwindSafe">RefUnwindSafe</a></li><li><a href="#impl-Send-for-Sender%3CT%3E" title="Send">Send</a></li><li><a href="#impl-Sync-for-Sender%3CT%3E" title="Sync">Sync</a></li><li><a href="#impl-Unpin-for-Sender%3CT%3E" title="Unpin">Unpin</a></li><li><a href="#impl-UnwindSafe-for-Sender%3CT%3E" title="UnwindSafe">UnwindSafe</a></li></ul><h3><a href="#blanket-implementations">Blanket Implementations</a></h3><ul class="block blanket-implementation"><li><a href="#impl-Any-for-T" title="Any">Any</a></li><li><a href="#impl-Borrow%3CT%3E-for-T" title="Borrow&#60;T&#62;">Borrow&#60;T&#62;</a></li><li><a href="#impl-BorrowMut%3CT%3E-for-T" title="BorrowMut&#60;T&#62;">BorrowMut&#60;T&#62;</a></li><li><a href="#impl-CloneToUninit-for-T" title="CloneToUninit">CloneToUninit</a></li><li><a href="#impl-From%3CT%3E-for-T" title="From&#60;T&#62;">From&#60;T&#62;</a></li><li><a href="#impl-Into%3CU%3E-for-T" title="Into&#60;U&#62;">Into&#60;U&#62;</a></li><li><a href="#impl-ToOwned-for-T" title="ToOwned">ToOwned</a></li><li><a href="#impl-TryFrom%3CU%3E-for-T" title="TryFrom&#60;U&#62;">TryFrom&#60;U&#62;</a></li><li><a href="#impl-TryInto%3CU%3E-for-T" title="TryInto&#60;U&#62;">TryInto&#60;U&#62;</a></li></ul></section><div id="rustdoc-modnav"><h2><a href="index.html">In tokio::<wbr>sync::<wbr>mpsc</a></h2></div></div></nav><div class="sidebar-resizer" title="Drag to resize sidebar"></div><main><div class="width-limiter"><section id="main-content" class="content"><div class="main-heading"><div class="rustdoc-breadcrumbs"><a href="../../index.html">tokio</a>::<wbr><a href="../index.html">sync</a>::<wbr><a href="index.html">mpsc</a></div><h1>Struct <span class="struct">Sender</span>&nbsp;<button id="copy-path" title="Copy item path to clipboard">Copy item path</button></h1><rustdoc-toolbar></rustdoc-toolbar><span class="sub-heading"><a class="src" href="../../../src/tokio/sync/mpsc/bounded.rs.html#22-24">Source</a> </span></div><pre class="rust item-decl"><code>pub struct Sender&lt;T&gt; { <span class="comment">/* private fields */</span> }</code></pre><details class="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" title="fn tokio::sync::mpsc::channel"><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/latest/tokio_util/sync/struct.PollSender.html"><code>PollSender</code></a> utility.</p>
</div></details><h2 id="implementations" class="section-header">Implementations<a href="#implementations" class="anchor">§</a></h2><div id="implementations-list"><details class="toggle implementors-toggle" open><summary><section id="impl-Sender%3CT%3E" class="impl"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#752-1598">Source</a><a href="#impl-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="struct" href="struct.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&gt;</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.send" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#816-824">Source</a><h4 class="code-header">pub async fn <a href="#method.send" class="fn">send</a>(&amp;self, value: T) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.93.1/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></section></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"><a class="doc-anchor" href="#errors">§</a>Errors</h5>
<p>If the receive half of the channel is closed, either due to <a href="struct.Receiver.html#method.close" title="method tokio::sync::mpsc::Receiver::close"><code>close</code></a>
being called or the <a href="struct.Receiver.html" title="struct tokio::sync::mpsc::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="cancel-safety"><a class="doc-anchor" href="#cancel-safety">§</a>Cancel safety</h5>
<p>If <code>send</code> is used as the event in a <a href="../../macro.select.html" title="macro tokio::select"><code>tokio::select!</code></a>
statement and some other branch completes first, then it is guaranteed
that the message was not sent. <strong>However, in that case, the message
is dropped and will be lost.</strong></p>
<p>To avoid losing messages, use <a href="struct.Sender.html#method.reserve" title="method tokio::sync::mpsc::Sender::reserve"><code>reserve</code></a> to reserve
capacity, then use the returned <a href="struct.Permit.html" title="struct tokio::sync::mpsc::Permit"><code>Permit</code></a> to send the message.</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"><a class="doc-anchor" href="#examples">§</a>Examples</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>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">1</span>);
tokio::spawn(<span class="kw">async move </span>{
<span class="kw">for </span>i <span class="kw">in </span><span class="number">0</span>..<span class="number">10 </span>{
<span class="kw">if let </span><span class="prelude-val">Err</span>(<span class="kw">_</span>) = tx.send(i).<span class="kw">await </span>{
<span class="macro">println!</span>(<span class="string">"receiver dropped"</span>);
<span class="kw">return</span>;
}
}
});
<span class="kw">while let </span><span class="prelude-val">Some</span>(i) = rx.recv().<span class="kw">await </span>{
<span class="macro">println!</span>(<span class="string">"got = {}"</span>, i);
}</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.closed" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#862-864">Source</a><h4 class="code-header">pub async fn <a href="#method.closed" class="fn">closed</a>(&amp;self)</h4></section></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"><a class="doc-anchor" href="#cancel-safety-1">§</a>Cancel safety</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"><a class="doc-anchor" href="#examples-1">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx1, rx) = mpsc::channel::&lt;()&gt;(<span class="number">1</span>);
<span class="kw">let </span>tx2 = tx1.clone();
<span class="kw">let </span>tx3 = tx1.clone();
<span class="kw">let </span>tx4 = tx1.clone();
<span class="kw">let </span>tx5 = tx1.clone();
tokio::spawn(<span class="kw">async move </span>{
drop(rx);
});
<span class="macro">futures::join!</span>(
tx1.closed(),
tx2.closed(),
tx3.closed(),
tx4.closed(),
tx5.closed()
);
<span class="macro">println!</span>(<span class="string">"Receiver dropped"</span>);</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.try_send" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#924-934">Source</a><h4 class="code-header">pub fn <a href="#method.try_send" class="fn">try_send</a>(&amp;self, message: T) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.93.1/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></section></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" title="method tokio::sync::mpsc::Sender::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" title="method tokio::sync::mpsc::Sender::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"><a class="doc-anchor" href="#errors-1">§</a>Errors</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" title="fn tokio::sync::mpsc::channel"><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" title="method tokio::sync::mpsc::Receiver::close"><code>close</code></a>
being called or the <a href="struct.Receiver.html" title="struct tokio::sync::mpsc::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"><a class="doc-anchor" href="#examples-2">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="comment">// Create a channel with buffer size 1
</span><span class="kw">let </span>(tx1, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">1</span>);
<span class="kw">let </span>tx2 = tx1.clone();
tokio::spawn(<span class="kw">async move </span>{
tx1.send(<span class="number">1</span>).<span class="kw">await</span>.unwrap();
tx1.send(<span class="number">2</span>).<span class="kw">await</span>.unwrap();
<span class="comment">// task waits until the receiver receives a value.
</span>});
tokio::spawn(<span class="kw">async move </span>{
<span class="comment">// This will return an error and send
// no message if the buffer is full
</span><span class="kw">let _ </span>= tx2.try_send(<span class="number">3</span>);
});
<span class="kw">let </span><span class="kw-2">mut </span>msg;
msg = rx.recv().<span class="kw">await</span>.unwrap();
<span class="macro">println!</span>(<span class="string">"message {} received"</span>, msg);
msg = rx.recv().<span class="kw">await</span>.unwrap();
<span class="macro">println!</span>(<span class="string">"message {} received"</span>, msg);
<span class="comment">// Third message may have never been sent
</span><span class="kw">match </span>rx.recv().<span class="kw">await </span>{
<span class="prelude-val">Some</span>(msg) =&gt; <span class="macro">println!</span>(<span class="string">"message {} received"</span>, msg),
<span class="prelude-val">None </span>=&gt; <span class="macro">println!</span>(<span class="string">"the third message was never sent"</span>),
}</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.send_timeout" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#988-1005">Source</a><h4 class="code-header">pub async fn <a href="#method.send_timeout" class="fn">send_timeout</a>(
&amp;self,
value: T,
timeout: <a class="struct" href="https://doc.rust-lang.org/1.93.1/core/time/struct.Duration.html" title="struct core::time::Duration">Duration</a>,
) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.93.1/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></section></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" title="method tokio::sync::mpsc::Sender::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"><a class="doc-anchor" href="#errors-2">§</a>Errors</h5>
<p>If the receive half of the channel is closed, either due to <a href="struct.Receiver.html#method.close" title="method tokio::sync::mpsc::Receiver::close"><code>close</code></a>
being called or the <a href="struct.Receiver.html" title="struct tokio::sync::mpsc::Receiver"><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"><a class="doc-anchor" href="#panics">§</a>Panics</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" title="method tokio::runtime::Builder::enable_time">with time enabled</a>.</p>
<h5 id="examples-3"><a class="doc-anchor" href="#examples-3">§</a>Examples</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>tokio::sync::mpsc;
<span class="kw">use </span>tokio::time::{sleep, Duration};
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">1</span>);
tokio::spawn(<span class="kw">async move </span>{
<span class="kw">for </span>i <span class="kw">in </span><span class="number">0</span>..<span class="number">10 </span>{
<span class="kw">if let </span><span class="prelude-val">Err</span>(e) = tx.send_timeout(i, Duration::from_millis(<span class="number">100</span>)).<span class="kw">await </span>{
<span class="macro">println!</span>(<span class="string">"send error: #{:?}"</span>, e);
<span class="kw">return</span>;
}
}
});
<span class="kw">while let </span><span class="prelude-val">Some</span>(i) = rx.recv().<span class="kw">await </span>{
<span class="macro">println!</span>(<span class="string">"got = {}"</span>, i);
sleep(Duration::from_millis(<span class="number">200</span>)).<span class="kw">await</span>;
}</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.blocking_send" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1046-1048">Source</a><h4 class="code-header">pub fn <a href="#method.blocking_send" class="fn">blocking_send</a>(&amp;self, value: T) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="primitive" href="https://doc.rust-lang.org/1.93.1/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></section></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" title="method tokio::sync::mpsc::Receiver::blocking_recv"><code>blocking_recv</code></a> to receive the message.</p>
<h5 id="panics-1"><a class="doc-anchor" href="#panics-1">§</a>Panics</h5>
<p>This function panics if called within an asynchronous execution
context.</p>
<h5 id="examples-4"><a class="doc-anchor" href="#examples-4">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>std::thread;
<span class="kw">use </span>tokio::runtime::Runtime;
<span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">fn </span>main() {
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel::&lt;u8&gt;(<span class="number">1</span>);
<span class="kw">let </span>sync_code = thread::spawn(<span class="kw">move </span>|| {
tx.blocking_send(<span class="number">10</span>).unwrap();
});
Runtime::new().unwrap().block_on(<span class="kw">async move </span>{
<span class="macro">assert_eq!</span>(<span class="prelude-val">Some</span>(<span class="number">10</span>), rx.recv().<span class="kw">await</span>);
});
sync_code.join().unwrap()
}</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.is_closed" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1068-1070">Source</a><h4 class="code-header">pub fn <a href="#method.is_closed" class="fn">is_closed</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Checks if the channel has been closed. This happens when the
<a href="struct.Receiver.html" title="struct tokio::sync::mpsc::Receiver"><code>Receiver</code></a> is dropped, or when the <a href="struct.Receiver.html#method.close" title="method tokio::sync::mpsc::Receiver::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>(tx, rx) = tokio::sync::mpsc::channel::&lt;()&gt;(<span class="number">42</span>);
<span class="macro">assert!</span>(!tx.is_closed());
<span class="kw">let </span>tx2 = tx.clone();
<span class="macro">assert!</span>(!tx2.is_closed());
drop(rx);
<span class="macro">assert!</span>(tx.is_closed());
<span class="macro">assert!</span>(tx2.is_closed());</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.reserve" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1116-1119">Source</a><h4 class="code-header">pub async fn <a href="#method.reserve" class="fn">reserve</a>(&amp;self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/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.93.1/std/primitive.unit.html">()</a>&gt;&gt;</h4></section></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" title="struct tokio::sync::mpsc::Permit"><code>Permit</code></a> is returned to track
the reserved capacity. The <a href="struct.Permit.html#method.send" title="method tokio::sync::mpsc::Permit::send"><code>send</code></a> function on <a href="struct.Permit.html" title="struct tokio::sync::mpsc::Permit"><code>Permit</code></a> consumes the
reserved capacity.</p>
<p>Dropping <a href="struct.Permit.html" title="struct tokio::sync::mpsc::Permit"><code>Permit</code></a> without sending a message releases the capacity back
to the channel.</p>
<h5 id="cancel-safety-2"><a class="doc-anchor" href="#cancel-safety-2">§</a>Cancel safety</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"><a class="doc-anchor" href="#examples-5">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">1</span>);
<span class="comment">// Reserve capacity
</span><span class="kw">let </span>permit = tx.reserve().<span class="kw">await</span>.unwrap();
<span class="comment">// Trying to send directly on the `tx` will fail due to no
// available capacity.
</span><span class="macro">assert!</span>(tx.try_send(<span class="number">123</span>).is_err());
<span class="comment">// Sending on the permit succeeds
</span>permit.send(<span class="number">456</span>);
<span class="comment">// The value sent on the permit is received
</span><span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">456</span>);</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.reserve_many" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1177-1183">Source</a><h4 class="code-header">pub async fn <a href="#method.reserve_many" class="fn">reserve_many</a>(
&amp;self,
n: <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.usize.html">usize</a>,
) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="struct" href="struct.PermitIterator.html" title="struct tokio::sync::mpsc::PermitIterator">PermitIterator</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.93.1/std/primitive.unit.html">()</a>&gt;&gt;</h4></section></summary><div class="docblock"><p>Waits for channel capacity. Once capacity to send <code>n</code> messages is
available, it is reserved for the caller.</p>
<p>If the channel is full or if there are fewer than <code>n</code> permits available, the function waits
for the number of unreceived messages to become <code>n</code> less than the channel capacity.
Capacity to send <code>n</code> message is then reserved for the caller.</p>
<p>A <a href="struct.PermitIterator.html" title="struct tokio::sync::mpsc::PermitIterator"><code>PermitIterator</code></a> is returned to track the reserved capacity.
You can call this <a href="https://doc.rust-lang.org/1.93.1/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator"><code>Iterator</code></a> until it is exhausted to
get a <a href="struct.Permit.html" title="struct tokio::sync::mpsc::Permit"><code>Permit</code></a> and then call <a href="struct.Permit.html#method.send" title="method tokio::sync::mpsc::Permit::send"><code>Permit::send</code></a>. This function is similar to
<a href="struct.Sender.html#method.try_reserve_many" title="method tokio::sync::mpsc::Sender::try_reserve_many"><code>try_reserve_many</code></a> except it waits for the slots to become available.</p>
<p>If the channel is closed, the function returns a <a href="error/struct.SendError.html" title="struct tokio::sync::mpsc::error::SendError"><code>SendError</code></a>.</p>
<p>Dropping <a href="struct.PermitIterator.html" title="struct tokio::sync::mpsc::PermitIterator"><code>PermitIterator</code></a> without consuming it entirely releases the remaining
permits back to the channel.</p>
<h5 id="cancel-safety-3"><a class="doc-anchor" href="#cancel-safety-3">§</a>Cancel safety</h5>
<p>This channel uses a queue to ensure that calls to <code>send</code> and <code>reserve_many</code>
complete in the order they were requested. Cancelling a call to
<code>reserve_many</code> makes you lose your place in the queue.</p>
<h5 id="examples-6"><a class="doc-anchor" href="#examples-6">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">2</span>);
<span class="comment">// Reserve capacity
</span><span class="kw">let </span><span class="kw-2">mut </span>permit = tx.reserve_many(<span class="number">2</span>).<span class="kw">await</span>.unwrap();
<span class="comment">// Trying to send directly on the `tx` will fail due to no
// available capacity.
</span><span class="macro">assert!</span>(tx.try_send(<span class="number">123</span>).is_err());
<span class="comment">// Sending with the permit iterator succeeds
</span>permit.next().unwrap().send(<span class="number">456</span>);
permit.next().unwrap().send(<span class="number">457</span>);
<span class="comment">// The iterator should now be exhausted
</span><span class="macro">assert!</span>(permit.next().is_none());
<span class="comment">// The value sent on the permit is received
</span><span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">456</span>);
<span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">457</span>);</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.reserve_owned" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1265-1270">Source</a><h4 class="code-header">pub async fn <a href="#method.reserve_owned" class="fn">reserve_owned</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/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.93.1/std/primitive.unit.html">()</a>&gt;&gt;</h4></section></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" title="method tokio::sync::mpsc::Sender::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.93.1/alloc/sync/struct.Arc.html#method.clone" title="method alloc::sync::Arc::clone"><code>Arc::clone</code></a>),
so when multiple <a href="struct.OwnedPermit.html" title="struct tokio::sync::mpsc::OwnedPermit"><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" title="struct tokio::sync::mpsc::OwnedPermit"><code>OwnedPermit</code></a> is returned to
track the reserved capacity. The <a href="struct.OwnedPermit.html#method.send" title="method tokio::sync::mpsc::OwnedPermit::send"><code>send</code></a> function on <a href="struct.OwnedPermit.html" title="struct tokio::sync::mpsc::OwnedPermit"><code>OwnedPermit</code></a>
consumes the reserved capacity.</p>
<p>Dropping the <a href="struct.OwnedPermit.html" title="struct tokio::sync::mpsc::OwnedPermit"><code>OwnedPermit</code></a> without sending a message releases the
capacity back to the channel.</p>
<h5 id="cancel-safety-4"><a class="doc-anchor" href="#cancel-safety-4">§</a>Cancel safety</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-7"><a class="doc-anchor" href="#examples-7">§</a>Examples</h5>
<p>Sending a message using an <a href="struct.OwnedPermit.html" title="struct tokio::sync::mpsc::OwnedPermit"><code>OwnedPermit</code></a>:</p>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">1</span>);
<span class="comment">// Reserve capacity, moving the sender.
</span><span class="kw">let </span>permit = tx.reserve_owned().<span class="kw">await</span>.unwrap();
<span class="comment">// Send a message, consuming the permit and returning
// the moved sender.
</span><span class="kw">let </span>tx = permit.send(<span class="number">123</span>);
<span class="comment">// The value sent on the permit is received.
</span><span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">123</span>);
<span class="comment">// The sender can now be used again.
</span>tx.send(<span class="number">456</span>).<span class="kw">await</span>.unwrap();</code></pre></div>
<p>When multiple <a href="struct.OwnedPermit.html" title="struct tokio::sync::mpsc::OwnedPermit"><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>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">1</span>);
<span class="comment">// Clone the sender and reserve capacity.
</span><span class="kw">let </span>permit = tx.clone().reserve_owned().<span class="kw">await</span>.unwrap();
<span class="comment">// Trying to send directly on the `tx` will fail due to no
// available capacity.
</span><span class="macro">assert!</span>(tx.try_send(<span class="number">123</span>).is_err());
<span class="comment">// Sending on the permit succeeds.
</span>permit.send(<span class="number">456</span>);
<span class="comment">// The value sent on the permit is received
</span><span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">456</span>);</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.try_reserve" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1327-1335">Source</a><h4 class="code-header">pub fn <a href="#method.try_reserve" class="fn">try_reserve</a>(&amp;self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/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.93.1/std/primitive.unit.html">()</a>&gt;&gt;</h4></section></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="enum tokio::sync::mpsc::error::TrySendError"><code>TrySendError</code></a>, otherwise
if there is a slot available it will return a <a href="struct.Permit.html" title="struct tokio::sync::mpsc::Permit"><code>Permit</code></a> that will then allow you
to <a href="struct.Permit.html#method.send" title="method tokio::sync::mpsc::Permit::send"><code>send</code></a> on the channel with a guaranteed slot. This function is similar to
<a href="struct.Sender.html#method.reserve" title="method tokio::sync::mpsc::Sender::reserve"><code>reserve</code></a> except it does not await for the slot to become available.</p>
<p>Dropping <a href="struct.Permit.html" title="struct tokio::sync::mpsc::Permit"><code>Permit</code></a> without sending a message releases the capacity back
to the channel.</p>
<h5 id="examples-8"><a class="doc-anchor" href="#examples-8">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">1</span>);
<span class="comment">// Reserve capacity
</span><span class="kw">let </span>permit = tx.try_reserve().unwrap();
<span class="comment">// Trying to send directly on the `tx` will fail due to no
// available capacity.
</span><span class="macro">assert!</span>(tx.try_send(<span class="number">123</span>).is_err());
<span class="comment">// Trying to reserve an additional slot on the `tx` will
// fail because there is no capacity.
</span><span class="macro">assert!</span>(tx.try_reserve().is_err());
<span class="comment">// Sending on the permit succeeds
</span>permit.send(<span class="number">456</span>);
<span class="comment">// The value sent on the permit is received
</span><span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">456</span>);
</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.try_reserve_many" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1405-1420">Source</a><h4 class="code-header">pub fn <a href="#method.try_reserve_many" class="fn">try_reserve_many</a>(
&amp;self,
n: <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.usize.html">usize</a>,
) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/core/result/enum.Result.html" title="enum core::result::Result">Result</a>&lt;<a class="struct" href="struct.PermitIterator.html" title="struct tokio::sync::mpsc::PermitIterator">PermitIterator</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.93.1/std/primitive.unit.html">()</a>&gt;&gt;</h4></section></summary><div class="docblock"><p>Tries to acquire <code>n</code> slots in the channel without waiting for the slot to become
available.</p>
<p>A <a href="struct.PermitIterator.html" title="struct tokio::sync::mpsc::PermitIterator"><code>PermitIterator</code></a> is returned to track the reserved capacity.
You can call this <a href="https://doc.rust-lang.org/1.93.1/core/iter/traits/iterator/trait.Iterator.html" title="trait core::iter::traits::iterator::Iterator"><code>Iterator</code></a> until it is exhausted to
get a <a href="struct.Permit.html" title="struct tokio::sync::mpsc::Permit"><code>Permit</code></a> and then call <a href="struct.Permit.html#method.send" title="method tokio::sync::mpsc::Permit::send"><code>Permit::send</code></a>. This function is similar to
<a href="struct.Sender.html#method.reserve_many" title="method tokio::sync::mpsc::Sender::reserve_many"><code>reserve_many</code></a> except it does not await for the slots to become available.</p>
<p>If there are fewer than <code>n</code> permits available on the channel, then
this function will return a <a href="error/enum.TrySendError.html#variant.Full" title="variant tokio::sync::mpsc::error::TrySendError::Full"><code>TrySendError::Full</code></a>. If the channel is closed
this function will return a <a href="error/enum.TrySendError.html#variant.Closed" title="variant tokio::sync::mpsc::error::TrySendError::Closed"><code>TrySendError::Closed</code></a>.</p>
<p>Dropping <a href="struct.PermitIterator.html" title="struct tokio::sync::mpsc::PermitIterator"><code>PermitIterator</code></a> without consuming it entirely releases the remaining
permits back to the channel.</p>
<h5 id="examples-9"><a class="doc-anchor" href="#examples-9">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">2</span>);
<span class="comment">// Reserve capacity
</span><span class="kw">let </span><span class="kw-2">mut </span>permit = tx.try_reserve_many(<span class="number">2</span>).unwrap();
<span class="comment">// Trying to send directly on the `tx` will fail due to no
// available capacity.
</span><span class="macro">assert!</span>(tx.try_send(<span class="number">123</span>).is_err());
<span class="comment">// Trying to reserve an additional slot on the `tx` will
// fail because there is no capacity.
</span><span class="macro">assert!</span>(tx.try_reserve().is_err());
<span class="comment">// Sending with the permit iterator succeeds
</span>permit.next().unwrap().send(<span class="number">456</span>);
permit.next().unwrap().send(<span class="number">457</span>);
<span class="comment">// The iterator should now be exhausted
</span><span class="macro">assert!</span>(permit.next().is_none());
<span class="comment">// The value sent on the permit is received
</span><span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">456</span>);
<span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">457</span>);
<span class="comment">// Trying to call try_reserve_many with 0 will return an empty iterator
</span><span class="kw">let </span><span class="kw-2">mut </span>permit = tx.try_reserve_many(<span class="number">0</span>).unwrap();
<span class="macro">assert!</span>(permit.next().is_none());
<span class="comment">// Trying to call try_reserve_many with a number greater than the channel
// capacity will return an error
</span><span class="kw">let </span>permit = tx.try_reserve_many(<span class="number">3</span>);
<span class="macro">assert!</span>(permit.is_err());
<span class="comment">// Trying to call try_reserve_many on a closed channel will return an error
</span>drop(rx);
<span class="kw">let </span>permit = tx.try_reserve_many(<span class="number">1</span>);
<span class="macro">assert!</span>(permit.is_err());
<span class="kw">let </span>permit = tx.try_reserve_many(<span class="number">0</span>);
<span class="macro">assert!</span>(permit.is_err());</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.try_reserve_owned" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1477-1487">Source</a><h4 class="code-header">pub fn <a href="#method.try_reserve_owned" class="fn">try_reserve_owned</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/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></section></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="method tokio::sync::mpsc::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.93.1/alloc/sync/struct.Arc.html#method.clone" title="method alloc::sync::Arc::clone"><code>Arc::clone</code></a>),
so when multiple <a href="struct.OwnedPermit.html" title="struct tokio::sync::mpsc::OwnedPermit"><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="enum tokio::sync::mpsc::error::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" title="struct tokio::sync::mpsc::OwnedPermit"><code>OwnedPermit</code></a>
that can then be used to <a href="struct.OwnedPermit.html#method.send" title="method tokio::sync::mpsc::OwnedPermit::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" title="method tokio::sync::mpsc::Sender::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" title="struct tokio::sync::mpsc::OwnedPermit"><code>OwnedPermit</code></a> without sending a message releases the capacity back
to the channel.</p>
<h5 id="examples-10"><a class="doc-anchor" href="#examples-10">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel(<span class="number">1</span>);
<span class="comment">// Reserve capacity
</span><span class="kw">let </span>permit = tx.clone().try_reserve_owned().unwrap();
<span class="comment">// Trying to send directly on the `tx` will fail due to no
// available capacity.
</span><span class="macro">assert!</span>(tx.try_send(<span class="number">123</span>).is_err());
<span class="comment">// Trying to reserve an additional slot on the `tx` will
// fail because there is no capacity.
</span><span class="macro">assert!</span>(tx.try_reserve().is_err());
<span class="comment">// Sending on the permit succeeds
</span>permit.send(<span class="number">456</span>);
<span class="comment">// The value sent on the permit is received
</span><span class="macro">assert_eq!</span>(rx.recv().<span class="kw">await</span>.unwrap(), <span class="number">456</span>);
</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.same_channel" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1501-1503">Source</a><h4 class="code-header">pub fn <a href="#method.same_channel" class="fn">same_channel</a>(&amp;self, other: &amp;Self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.bool.html">bool</a></h4></section></summary><div class="docblock"><p>Returns <code>true</code> if senders belong to the same channel.</p>
<h5 id="examples-11"><a class="doc-anchor" href="#examples-11">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">let </span>(tx, rx) = tokio::sync::mpsc::channel::&lt;()&gt;(<span class="number">1</span>);
<span class="kw">let </span>tx2 = tx.clone();
<span class="macro">assert!</span>(tx.same_channel(<span class="kw-2">&amp;</span>tx2));
<span class="kw">let </span>(tx3, rx3) = tokio::sync::mpsc::channel::&lt;()&gt;(<span class="number">1</span>);
<span class="macro">assert!</span>(!tx3.same_channel(<span class="kw-2">&amp;</span>tx2));</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.capacity" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1538-1540">Source</a><h4 class="code-header">pub fn <a href="#method.capacity" class="fn">capacity</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.usize.html">usize</a></h4></section></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" title="method tokio::sync::mpsc::Sender::send"><code>send</code></a> or by reserving capacity
with <a href="struct.Sender.html#method.reserve" title="method tokio::sync::mpsc::Sender::reserve"><code>reserve</code></a>. The capacity goes up when values are received by the <a href="struct.Receiver.html" title="struct tokio::sync::mpsc::Receiver"><code>Receiver</code></a>.
This is distinct from <a href="struct.Sender.html#method.max_capacity" title="method tokio::sync::mpsc::Sender::max_capacity"><code>max_capacity</code></a>, which always returns buffer capacity initially
specified when calling <a href="fn.channel.html" title="fn tokio::sync::mpsc::channel"><code>channel</code></a></p>
<h5 id="examples-12"><a class="doc-anchor" href="#examples-12">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx, <span class="kw-2">mut </span>rx) = mpsc::channel::&lt;()&gt;(<span class="number">5</span>);
<span class="macro">assert_eq!</span>(tx.capacity(), <span class="number">5</span>);
<span class="comment">// Making a reservation drops the capacity by one.
</span><span class="kw">let </span>permit = tx.reserve().<span class="kw">await</span>.unwrap();
<span class="macro">assert_eq!</span>(tx.capacity(), <span class="number">4</span>);
<span class="comment">// Sending and receiving a value increases the capacity by one.
</span>permit.send(());
rx.recv().<span class="kw">await</span>.unwrap();
<span class="macro">assert_eq!</span>(tx.capacity(), <span class="number">5</span>);</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.downgrade" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1547-1551">Source</a><h4 class="code-header">pub fn <a href="#method.downgrade" class="fn">downgrade</a>(&amp;self) -&gt; <a class="struct" href="struct.WeakSender.html" title="struct tokio::sync::mpsc::WeakSender">WeakSender</a>&lt;T&gt;</h4></section></summary><div class="docblock"><p>Converts the <code>Sender</code> to a <a href="struct.WeakSender.html" title="struct tokio::sync::mpsc::WeakSender"><code>WeakSender</code></a> that does not count
towards RAII semantics, i.e. if all <code>Sender</code> instances of the
channel were dropped and only <code>WeakSender</code> instances remain,
the channel is closed.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.max_capacity" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1585-1587">Source</a><h4 class="code-header">pub fn <a href="#method.max_capacity" class="fn">max_capacity</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.usize.html">usize</a></h4></section></summary><div class="docblock"><p>Returns the maximum buffer capacity of the channel.</p>
<p>The maximum capacity is the buffer capacity initially specified when calling
<a href="fn.channel.html" title="fn tokio::sync::mpsc::channel"><code>channel</code></a>. This is distinct from <a href="struct.Sender.html#method.capacity" title="method tokio::sync::mpsc::Sender::capacity"><code>capacity</code></a>, which returns the <em>current</em>
available buffer capacity: as messages are sent and received, the
value returned by <a href="struct.Sender.html#method.capacity" title="method tokio::sync::mpsc::Sender::capacity"><code>capacity</code></a> will go up or down, whereas the value
returned by <a href="struct.Sender.html#method.max_capacity" title="method tokio::sync::mpsc::Sender::max_capacity"><code>max_capacity</code></a> will remain constant.</p>
<h5 id="examples-13"><a class="doc-anchor" href="#examples-13">§</a>Examples</h5>
<div class="example-wrap"><pre class="rust rust-example-rendered"><code><span class="kw">use </span>tokio::sync::mpsc;
<span class="kw">let </span>(tx, _rx) = mpsc::channel::&lt;()&gt;(<span class="number">5</span>);
<span class="comment">// both max capacity and capacity are the same at first
</span><span class="macro">assert_eq!</span>(tx.max_capacity(), <span class="number">5</span>);
<span class="macro">assert_eq!</span>(tx.capacity(), <span class="number">5</span>);
<span class="comment">// Making a reservation doesn't change the max capacity.
</span><span class="kw">let </span>permit = tx.reserve().<span class="kw">await</span>.unwrap();
<span class="macro">assert_eq!</span>(tx.max_capacity(), <span class="number">5</span>);
<span class="comment">// but drops the capacity by one
</span><span class="macro">assert_eq!</span>(tx.capacity(), <span class="number">4</span>);</code></pre></div></div></details><details class="toggle method-toggle" open><summary><section id="method.strong_count" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1590-1592">Source</a><h4 class="code-header">pub fn <a href="#method.strong_count" class="fn">strong_count</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.usize.html">usize</a></h4></section></summary><div class="docblock"><p>Returns the number of <a href="struct.Sender.html" title="struct tokio::sync::mpsc::Sender"><code>Sender</code></a> handles.</p>
</div></details><details class="toggle method-toggle" open><summary><section id="method.weak_count" class="method"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1595-1597">Source</a><h4 class="code-header">pub fn <a href="#method.weak_count" class="fn">weak_count</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.usize.html">usize</a></h4></section></summary><div class="docblock"><p>Returns the number of <a href="struct.WeakSender.html" title="struct tokio::sync::mpsc::WeakSender"><code>WeakSender</code></a> handles.</p>
</div></details></div></details></div><h2 id="trait-implementations" class="section-header">Trait Implementations<a href="#trait-implementations" class="anchor">§</a></h2><div id="trait-implementations-list"><details class="toggle implementors-toggle" open><summary><section id="impl-Clone-for-Sender%3CT%3E" class="impl"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1600-1606">Source</a><a href="#impl-Clone-for-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/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></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.clone" class="method trait-impl"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1601-1605">Source</a><a href="#method.clone" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/clone/trait.Clone.html#tymethod.clone" class="fn">clone</a>(&amp;self) -&gt; Self</h4></section></summary><div class='docblock'>Returns a duplicate of the value. <a href="https://doc.rust-lang.org/1.93.1/core/clone/trait.Clone.html#tymethod.clone">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.clone_from" class="method trait-impl"><span class="rightside"><span class="since" title="Stable since Rust version 1.0.0">1.0.0</span> · <a class="src" href="https://doc.rust-lang.org/1.93.1/src/core/clone.rs.html#245-247">Source</a></span><a href="#method.clone_from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/clone/trait.Clone.html#method.clone_from" class="fn">clone_from</a>(&amp;mut self, source: &amp;Self)</h4></section></summary><div class='docblock'>Performs copy-assignment from <code>source</code>. <a href="https://doc.rust-lang.org/1.93.1/core/clone/trait.Clone.html#method.clone_from">Read more</a></div></details></div></details><details class="toggle implementors-toggle" open><summary><section id="impl-Debug-for-Sender%3CT%3E" class="impl"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1608-1614">Source</a><a href="#impl-Debug-for-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/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></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.fmt" class="method trait-impl"><a class="src rightside" href="../../../src/tokio/sync/mpsc/bounded.rs.html#1609-1613">Source</a><a href="#method.fmt" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/fmt/trait.Debug.html#tymethod.fmt" class="fn">fmt</a>(&amp;self, fmt: &amp;mut <a class="struct" href="https://doc.rust-lang.org/1.93.1/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.93.1/core/fmt/type.Result.html" title="type core::fmt::Result">Result</a></h4></section></summary><div class='docblock'>Formats the value using the given formatter. <a href="https://doc.rust-lang.org/1.93.1/core/fmt/trait.Debug.html#tymethod.fmt">Read more</a></div></details></div></details></div><h2 id="synthetic-implementations" class="section-header">Auto Trait Implementations<a href="#synthetic-implementations" class="anchor">§</a></h2><div id="synthetic-implementations-list"><section id="impl-Freeze-for-Sender%3CT%3E" class="impl"><a href="#impl-Freeze-for-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/marker/trait.Freeze.html" title="trait core::marker::Freeze">Freeze</a> for <a class="struct" href="struct.Sender.html" title="struct tokio::sync::mpsc::Sender">Sender</a>&lt;T&gt;</h3></section><section id="impl-RefUnwindSafe-for-Sender%3CT%3E" class="impl"><a href="#impl-RefUnwindSafe-for-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/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></section><section id="impl-Send-for-Sender%3CT%3E" class="impl"><a href="#impl-Send-for-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/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;<div class="where">where
T: <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,</div></h3></section><section id="impl-Sync-for-Sender%3CT%3E" class="impl"><a href="#impl-Sync-for-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/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;<div class="where">where
T: <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>,</div></h3></section><section id="impl-Unpin-for-Sender%3CT%3E" class="impl"><a href="#impl-Unpin-for-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/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></section><section id="impl-UnwindSafe-for-Sender%3CT%3E" class="impl"><a href="#impl-UnwindSafe-for-Sender%3CT%3E" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/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></section></div><h2 id="blanket-implementations" class="section-header">Blanket Implementations<a href="#blanket-implementations" class="anchor">§</a></h2><div id="blanket-implementations-list"><details class="toggle implementors-toggle"><summary><section id="impl-Any-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/any.rs.html#138">Source</a><a href="#impl-Any-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/any/trait.Any.html" title="trait core::any::Any">Any</a> for T<div class="where">where
T: 'static + ?<a class="trait" href="https://doc.rust-lang.org/1.93.1/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.type_id" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/any.rs.html#139">Source</a><a href="#method.type_id" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/any/trait.Any.html#tymethod.type_id" class="fn">type_id</a>(&amp;self) -&gt; <a class="struct" href="https://doc.rust-lang.org/1.93.1/core/any/struct.TypeId.html" title="struct core::any::TypeId">TypeId</a></h4></section></summary><div class='docblock'>Gets the <code>TypeId</code> of <code>self</code>. <a href="https://doc.rust-lang.org/1.93.1/core/any/trait.Any.html#tymethod.type_id">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Borrow%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/borrow.rs.html#212">Source</a><a href="#impl-Borrow%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/borrow/trait.Borrow.html" title="trait core::borrow::Borrow">Borrow</a>&lt;T&gt; for T<div class="where">where
T: ?<a class="trait" href="https://doc.rust-lang.org/1.93.1/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.borrow" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/borrow.rs.html#214">Source</a><a href="#method.borrow" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/borrow/trait.Borrow.html#tymethod.borrow" class="fn">borrow</a>(&amp;self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.reference.html">&amp;T</a></h4></section></summary><div class='docblock'>Immutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.93.1/core/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-BorrowMut%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/borrow.rs.html#221">Source</a><a href="#impl-BorrowMut%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/borrow/trait.BorrowMut.html" title="trait core::borrow::BorrowMut">BorrowMut</a>&lt;T&gt; for T<div class="where">where
T: ?<a class="trait" href="https://doc.rust-lang.org/1.93.1/core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.borrow_mut" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/borrow.rs.html#222">Source</a><a href="#method.borrow_mut" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut" class="fn">borrow_mut</a>(&amp;mut self) -&gt; <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.reference.html">&amp;mut T</a></h4></section></summary><div class='docblock'>Mutably borrows from an owned value. <a href="https://doc.rust-lang.org/1.93.1/core/borrow/trait.BorrowMut.html#tymethod.borrow_mut">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-CloneToUninit-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/clone.rs.html#547">Source</a><a href="#impl-CloneToUninit-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/clone/trait.CloneToUninit.html" title="trait core::clone::CloneToUninit">CloneToUninit</a> for T<div class="where">where
T: <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.clone_to_uninit" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/clone.rs.html#549">Source</a><a href="#method.clone_to_uninit" class="anchor">§</a><h4 class="code-header">unsafe fn <a href="https://doc.rust-lang.org/1.93.1/core/clone/trait.CloneToUninit.html#tymethod.clone_to_uninit" class="fn">clone_to_uninit</a>(&amp;self, dest: <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.pointer.html">*mut </a><a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.u8.html">u8</a>)</h4></section></summary><span class="item-info"><div class="stab unstable"><span class="emoji">🔬</span><span>This is a nightly-only experimental API. (<code>clone_to_uninit</code>)</span></div></span><div class='docblock'>Performs copy-assignment from <code>self</code> to <code>dest</code>. <a href="https://doc.rust-lang.org/1.93.1/core/clone/trait.CloneToUninit.html#tymethod.clone_to_uninit">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-From%3CT%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#785">Source</a><a href="#impl-From%3CT%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for T</h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.from" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#788">Source</a><a href="#method.from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/convert/trait.From.html#tymethod.from" class="fn">from</a>(t: T) -&gt; T</h4></section></summary><div class="docblock"><p>Returns the argument unchanged.</p>
</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-Into%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#767-769">Source</a><a href="#impl-Into%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;U&gt; for T<div class="where">where
U: <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle method-toggle" open><summary><section id="method.into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#777">Source</a><a href="#method.into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/convert/trait.Into.html#tymethod.into" class="fn">into</a>(self) -&gt; U</h4></section></summary><div class="docblock"><p>Calls <code>U::from(self)</code>.</p>
<p>That is, this conversion is whatever the implementation of
<code><a href="https://doc.rust-lang.org/1.93.1/core/convert/trait.From.html" title="trait core::convert::From">From</a>&lt;T&gt; for U</code> chooses to do.</p>
</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-ToOwned-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/alloc/borrow.rs.html#85-87">Source</a><a href="#impl-ToOwned-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/alloc/borrow/trait.ToOwned.html" title="trait alloc::borrow::ToOwned">ToOwned</a> for T<div class="where">where
T: <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Owned" class="associatedtype trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/alloc/borrow.rs.html#89">Source</a><a href="#associatedtype.Owned" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.93.1/alloc/borrow/trait.ToOwned.html#associatedtype.Owned" class="associatedtype">Owned</a> = T</h4></section></summary><div class='docblock'>The resulting type after obtaining ownership.</div></details><details class="toggle method-toggle" open><summary><section id="method.to_owned" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/alloc/borrow.rs.html#90">Source</a><a href="#method.to_owned" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/alloc/borrow/trait.ToOwned.html#tymethod.to_owned" class="fn">to_owned</a>(&amp;self) -&gt; T</h4></section></summary><div class='docblock'>Creates owned data from borrowed data, usually by cloning. <a href="https://doc.rust-lang.org/1.93.1/alloc/borrow/trait.ToOwned.html#tymethod.to_owned">Read more</a></div></details><details class="toggle method-toggle" open><summary><section id="method.clone_into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/alloc/borrow.rs.html#94">Source</a><a href="#method.clone_into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/alloc/borrow/trait.ToOwned.html#method.clone_into" class="fn">clone_into</a>(&amp;self, target: <a class="primitive" href="https://doc.rust-lang.org/1.93.1/std/primitive.reference.html">&amp;mut T</a>)</h4></section></summary><div class='docblock'>Uses borrowed data to replace owned data, usually by cloning. <a href="https://doc.rust-lang.org/1.93.1/alloc/borrow/trait.ToOwned.html#method.clone_into">Read more</a></div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-TryFrom%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#827-829">Source</a><a href="#impl-TryFrom%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;U&gt; for T<div class="where">where
U: <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/convert/trait.Into.html" title="trait core::convert::Into">Into</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Error-1" class="associatedtype trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#831">Source</a><a href="#associatedtype.Error-1" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.93.1/core/convert/trait.TryFrom.html#associatedtype.Error" class="associatedtype">Error</a> = <a class="enum" href="https://doc.rust-lang.org/1.93.1/core/convert/enum.Infallible.html" title="enum core::convert::Infallible">Infallible</a></h4></section></summary><div class='docblock'>The type returned in the event of a conversion error.</div></details><details class="toggle method-toggle" open><summary><section id="method.try_from" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#834">Source</a><a href="#method.try_from" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/convert/trait.TryFrom.html#tymethod.try_from" class="fn">try_from</a>(value: U) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/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.93.1/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.93.1/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></section></summary><div class='docblock'>Performs the conversion.</div></details></div></details><details class="toggle implementors-toggle"><summary><section id="impl-TryInto%3CU%3E-for-T" class="impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#811-813">Source</a><a href="#impl-TryInto%3CU%3E-for-T" class="anchor">§</a><h3 class="code-header">impl&lt;T, U&gt; <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/convert/trait.TryInto.html" title="trait core::convert::TryInto">TryInto</a>&lt;U&gt; for T<div class="where">where
U: <a class="trait" href="https://doc.rust-lang.org/1.93.1/core/convert/trait.TryFrom.html" title="trait core::convert::TryFrom">TryFrom</a>&lt;T&gt;,</div></h3></section></summary><div class="impl-items"><details class="toggle" open><summary><section id="associatedtype.Error" class="associatedtype trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#815">Source</a><a href="#associatedtype.Error" class="anchor">§</a><h4 class="code-header">type <a href="https://doc.rust-lang.org/1.93.1/core/convert/trait.TryInto.html#associatedtype.Error" class="associatedtype">Error</a> = &lt;U as <a class="trait" href="https://doc.rust-lang.org/1.93.1/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.93.1/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a></h4></section></summary><div class='docblock'>The type returned in the event of a conversion error.</div></details><details class="toggle method-toggle" open><summary><section id="method.try_into" class="method trait-impl"><a class="src rightside" href="https://doc.rust-lang.org/1.93.1/src/core/convert/mod.rs.html#818">Source</a><a href="#method.try_into" class="anchor">§</a><h4 class="code-header">fn <a href="https://doc.rust-lang.org/1.93.1/core/convert/trait.TryInto.html#tymethod.try_into" class="fn">try_into</a>(self) -&gt; <a class="enum" href="https://doc.rust-lang.org/1.93.1/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.93.1/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.93.1/core/convert/trait.TryFrom.html#associatedtype.Error" title="type core::convert::TryFrom::Error">Error</a>&gt;</h4></section></summary><div class='docblock'>Performs the conversion.</div></details></div></details></div></section></div></main></body></html>
Reference in New Issue View Git Blame Copy Permalink