<!DOCTYPE html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta name="generator" content="rustdoc"><meta name="description" content="API documentation for the Rust `Arc` struct in crate `alloc`."><meta name="keywords" content="rust, rustlang, rust-lang, Arc"><title>alloc::arc::Arc - Rust</title><link rel="stylesheet" type="text/css" href="../../normalize.css"><link rel="stylesheet" type="text/css" href="../../rustdoc.css" id="mainThemeStyle"><link rel="stylesheet" type="text/css" href="../../dark.css"><link rel="stylesheet" type="text/css" href="../../light.css" id="themeStyle"><script src="../../storage.js"></script><link rel="shortcut icon" href="https://doc.rust-lang.org/favicon.ico"></head><body class="rustdoc struct"><!--[if lte IE 8]><div class="warning">This old browser is unsupported and will most likely display funky things.</div><![endif]--><nav class="sidebar"><div class="sidebar-menu">☰</div><a href='../../alloc/index.html'><img src='https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png' alt='logo' width='100'></a><p class='location'>Struct Arc</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.new">new</a><a href="#method.try_unwrap">try_unwrap</a><a href="#method.into_raw">into_raw</a><a href="#method.from_raw">from_raw</a><a href="#method.downgrade">downgrade</a><a href="#method.weak_count">weak_count</a><a href="#method.strong_count">strong_count</a><a href="#method.ptr_eq">ptr_eq</a><a href="#method.make_mut">make_mut</a><a href="#method.get_mut">get_mut</a><a href="#method.downcast">downcast</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-From%3CArc%3CT%3E%3E">From<Arc<T>></a><a href="#impl-Send">Send</a><a href="#impl-Sync">Sync</a><a href="#impl-CoerceUnsized%3CArc%3CU%3E%3E">CoerceUnsized<Arc<U>></a><a href="#impl-Clone">Clone</a><a href="#impl-Deref">Deref</a><a href="#impl-Drop">Drop</a><a href="#impl-PartialEq">PartialEq</a><a href="#impl-PartialOrd">PartialOrd</a><a href="#impl-Ord">Ord</a><a href="#impl-Eq">Eq</a><a href="#impl-Display">Display</a><a href="#impl-Debug">Debug</a><a href="#impl-Pointer">Pointer</a><a href="#impl-Default">Default</a><a href="#impl-Hash">Hash</a><a href="#impl-From%3CT%3E">From<T></a><a href="#impl-From%3C%26%27a%20%5BT%5D%3E">From<&'a [T]></a><a href="#impl-From%3C%26%27a%20str%3E">From<&'a str></a><a href="#impl-From%3CString%3E">From<String></a><a href="#impl-From%3CBox%3CT%3E%3E">From<Box<T>></a><a href="#impl-From%3CVec%3CT%3E%3E">From<Vec<T>></a><a href="#impl-Borrow%3CT%3E">Borrow<T></a><a href="#impl-AsRef%3CT%3E">AsRef<T></a></div></div><p class='location'><a href='../index.html'>alloc</a>::<wbr><a href='index.html'>arc</a></p><script>window.sidebarCurrent = {name: 'Arc', ty: 'struct', relpath: ''};</script><script defer src="sidebar-items.js"></script></div></nav><div class="theme-picker"><button id="theme-picker" aria-label="Pick another theme!"><img src="../../brush.svg" width="18" alt="Pick another theme!"></button><div id="theme-choices"></div></div><script src="../../theme.js"></script><nav class="sub"><form class="search-form js-only"><div class="search-container"><input class="search-input" name="search" autocomplete="off" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"><a id="settings-menu" href="../../settings.html"><img src="../../wheel.svg" width="18" alt="Change settings"></a></div></form></nav><section id="main" class="content"><h1 class='fqn'><span class='in-band'>Struct <a href='../index.html'>alloc</a>::<wbr><a href='index.html'>arc</a>::<wbr><a class="struct" href=''>Arc</a></span><span class='out-of-band'><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><span id='render-detail'><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class='inner'>−</span>]</a></span><a class='srclink' href='../../src/alloc/arc.rs.html#200-203' title='goto source code'>[src]</a></span></h1><div class="docblock type-decl"><pre class='rust struct'>pub struct Arc<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> { /* fields omitted */ }</pre></div><div class='docblock'><p>A thread-safe reference-counting pointer. 'Arc' stands for 'Atomically
Reference Counted'.</p>
<p>The type <code>Arc<T></code> provides shared ownership of a value of type <code>T</code>,
allocated in the heap. Invoking <a href="../../std/clone/trait.Clone.html#tymethod.clone"><code>clone</code></a> on <code>Arc</code> produces
a new pointer to the same value in the heap. When the last <code>Arc</code>
pointer to a given value is destroyed, the pointed-to value is
also destroyed.</p>
<p>Shared references in Rust disallow mutation by default, and <code>Arc</code> is no
exception: you cannot generally obtain a mutable reference to something
inside an <code>Arc</code>. If you need to mutate through an <code>Arc</code>, use
<a href="../../std/sync/struct.Mutex.html"><code>Mutex</code></a>, <a href="../../std/sync/struct.RwLock.html"><code>RwLock</code></a>, or one of the <a href="../../std/sync/atomic/index.html"><code>Atomic</code></a>
types.</p>
<h2 id="thread-safety" class="section-header"><a href="#thread-safety">Thread Safety</a></h2>
<p>Unlike <a href="../../std/rc/struct.Rc.html"><code>Rc<T></code></a>, <code>Arc<T></code> uses atomic operations for its reference
counting. This means that it is thread-safe. The disadvantage is that
atomic operations are more expensive than ordinary memory accesses. If you
are not sharing reference-counted values between threads, consider using
<a href="../../std/rc/struct.Rc.html"><code>Rc<T></code></a> for lower overhead. <a href="../../std/rc/struct.Rc.html"><code>Rc<T></code></a> is a safe default, because the
compiler will catch any attempt to send an <a href="../../std/rc/struct.Rc.html"><code>Rc<T></code></a> between threads.
However, a library might choose <code>Arc<T></code> in order to give library consumers
more flexibility.</p>
<p><code>Arc<T></code> will implement <a href="../../std/marker/trait.Send.html"><code>Send</code></a> and <a href="../../std/marker/trait.Sync.html"><code>Sync</code></a> as long as the <code>T</code> implements
<a href="../../std/marker/trait.Send.html"><code>Send</code></a> and <a href="../../std/marker/trait.Sync.html"><code>Sync</code></a>. Why can't you put a non-thread-safe type <code>T</code> in an
<code>Arc<T></code> to make it thread-safe? This may be a bit counter-intuitive at
first: after all, isn't the point of <code>Arc<T></code> thread safety? The key is
this: <code>Arc<T></code> makes it thread safe to have multiple ownership of the same
data, but it doesn't add thread safety to its data. Consider
<code>Arc<</code><a href="../../std/cell/struct.RefCell.html"><code>RefCell<T></code></a><code>></code>. <a href="../../std/cell/struct.RefCell.html"><code>RefCell<T></code></a> isn't <a href="../../std/marker/trait.Sync.html"><code>Sync</code></a>, and if <code>Arc<T></code> was always
<a href="../../std/marker/trait.Send.html"><code>Send</code></a>, <code>Arc<</code><a href="../../std/cell/struct.RefCell.html"><code>RefCell<T></code></a><code>></code> would be as well. But then we'd have a problem:
<a href="../../std/cell/struct.RefCell.html"><code>RefCell<T></code></a> is not thread safe; it keeps track of the borrowing count using
non-atomic operations.</p>
<p>In the end, this means that you may need to pair <code>Arc<T></code> with some sort of
<a href="../../std/sync/index.html"><code>std::sync</code></a> type, usually <a href="../../std/sync/struct.Mutex.html"><code>Mutex<T></code></a>.</p>
<h2 id="breaking-cycles-with-weak" class="section-header"><a href="#breaking-cycles-with-weak">Breaking cycles with <code>Weak</code></a></h2>
<p>The <a href="struct.Arc.html#method.downgrade"><code>downgrade</code></a> method can be used to create a non-owning
<a href="struct.Weak.html"><code>Weak</code></a> pointer. A <a href="struct.Weak.html"><code>Weak</code></a> pointer can be <a href="struct.Weak.html#method.upgrade"><code>upgrade</code></a>d
to an <code>Arc</code>, but this will return <a href="../../std/option/enum.Option.html#variant.None"><code>None</code></a> if the value has already been
dropped.</p>
<p>A cycle between <code>Arc</code> pointers will never be deallocated. For this reason,
<a href="struct.Weak.html"><code>Weak</code></a> is used to break cycles. For example, a tree could have
strong <code>Arc</code> pointers from parent nodes to children, and <a href="struct.Weak.html"><code>Weak</code></a>
pointers from children back to their parents.</p>
<h1 id="cloning-references" class="section-header"><a href="#cloning-references">Cloning references</a></h1>
<p>Creating a new reference from an existing reference counted pointer is done using the
<code>Clone</code> trait implemented for <a href="struct.Arc.html"><code>Arc<T></code></a> and <a href="struct.Weak.html"><code>Weak<T></code></a>.</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">foo</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="macro">vec</span><span class="macro">!</span>[<span class="number">1.0</span>, <span class="number">2.0</span>, <span class="number">3.0</span>]);
<span class="comment">// The two syntaxes below are equivalent.</span>
<span class="kw">let</span> <span class="ident">a</span> <span class="op">=</span> <span class="ident">foo</span>.<span class="ident">clone</span>();
<span class="kw">let</span> <span class="ident">b</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">foo</span>);
<span class="comment">// a and b both point to the same memory location as foo.</span></pre>
<p>The <a href="#method.clone"><code>Arc::clone(&from)</code></a> syntax is the most idiomatic because it conveys more explicitly
the meaning of the code. In the example above, this syntax makes it easier to see that
this code is creating a new reference rather than copying the whole content of foo.</p>
<h2 id="deref-behavior" class="section-header"><a href="#deref-behavior"><code>Deref</code> behavior</a></h2>
<p><code>Arc<T></code> automatically dereferences to <code>T</code> (via the <a href="../../std/ops/trait.Deref.html"><code>Deref</code></a> trait),
so you can call <code>T</code>'s methods on a value of type <code>Arc<T></code>. To avoid name
clashes with <code>T</code>'s methods, the methods of <code>Arc<T></code> itself are <a href="../../book/first-edition/method-syntax.html#associated-functions">associated
functions</a>, called using function-like syntax:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">my_arc</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(());
<span class="ident">Arc</span>::<span class="ident">downgrade</span>(<span class="kw-2">&</span><span class="ident">my_arc</span>);</pre>
<p><a href="struct.Weak.html"><code>Weak<T></code></a> does not auto-dereference to <code>T</code>, because the value may have
already been destroyed.</p>
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
<p>Sharing some immutable data between threads:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">thread</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="kw">for</span> <span class="kw">_</span> <span class="kw">in</span> <span class="number">0</span>..<span class="number">10</span> {
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">five</span>);
<span class="ident">thread</span>::<span class="ident">spawn</span>(<span class="kw">move</span> <span class="op">||</span> {
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"{:?}"</span>, <span class="ident">five</span>);
});
}</pre>
<p>Sharing a mutable <a href="../../std/sync/atomic/struct.AtomicUsize.html"><code>AtomicUsize</code></a>:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">atomic</span>::{<span class="ident">AtomicUsize</span>, <span class="ident">Ordering</span>};
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">thread</span>;
<span class="kw">let</span> <span class="ident">val</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">AtomicUsize</span>::<span class="ident">new</span>(<span class="number">5</span>));
<span class="kw">for</span> <span class="kw">_</span> <span class="kw">in</span> <span class="number">0</span>..<span class="number">10</span> {
<span class="kw">let</span> <span class="ident">val</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">val</span>);
<span class="ident">thread</span>::<span class="ident">spawn</span>(<span class="kw">move</span> <span class="op">||</span> {
<span class="kw">let</span> <span class="ident">v</span> <span class="op">=</span> <span class="ident">val</span>.<span class="ident">fetch_add</span>(<span class="number">1</span>, <span class="ident">Ordering</span>::<span class="ident">SeqCst</span>);
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"{:?}"</span>, <span class="ident">v</span>);
});
}</pre>
<p>See the <a href="../../std/rc/index.html#examples"><code>rc</code> documentation</a> for more examples of reference
counting in general.</p>
</div>
<h2 id='methods' class='small-section-header'>
Methods<a href='#methods' class='anchor'></a>
</h2>
<h3 id='impl' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#270-334' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.new' class="method"><span id='new.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.new' class='fnname'>new</a>(data: T) -> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#282-291' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Constructs a new <code>Arc<T></code>.</p>
<h1 id="examples-1" class="section-header"><a href="#examples-1">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);</pre>
</div><h4 id='method.try_unwrap' class="method"><span id='try_unwrap.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.try_unwrap' class='fnname'>try_unwrap</a>(this: Self) -> <a class="enum" href="../../core/result/enum.Result.html" title="enum core::result::Result">Result</a><T, Self></code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.4.0'>1.4.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#316-333' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Returns the contained value, if the <code>Arc</code> has exactly one strong reference.</p>
<p>Otherwise, an <a href="../../std/result/enum.Result.html"><code>Err</code></a> is returned with the same <code>Arc</code> that was
passed in.</p>
<p>This will succeed even if there are outstanding weak references.</p>
<h1 id="examples-2" class="section-header"><a href="#examples-2">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">3</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">Arc</span>::<span class="ident">try_unwrap</span>(<span class="ident">x</span>), <span class="prelude-val">Ok</span>(<span class="number">3</span>));
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">4</span>);
<span class="kw">let</span> <span class="ident">_y</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">x</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">Arc</span>::<span class="ident">try_unwrap</span>(<span class="ident">x</span>).<span class="ident">unwrap_err</span>(), <span class="number">4</span>);</pre>
</div></div><h3 id='impl-1' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-1' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#336-546' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.into_raw' class="method"><span id='into_raw.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.into_raw' class='fnname'>into_raw</a>(this: Self) -> *const T</code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.17.0'>1.17.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#354-358' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Consumes the <code>Arc</code>, returning the wrapped pointer.</p>
<p>To avoid a memory leak the pointer must be converted back to an <code>Arc</code> using
<a href="struct.Arc.html#method.from_raw"><code>Arc::from_raw</code></a>.</p>
<h1 id="examples-3" class="section-header"><a href="#examples-3">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">10</span>);
<span class="kw">let</span> <span class="ident">x_ptr</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">into_raw</span>(<span class="ident">x</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw">unsafe</span> { <span class="kw-2">*</span><span class="ident">x_ptr</span> }, <span class="number">10</span>);</pre>
</div><h4 id='method.from_raw' class="method"><span id='from_raw.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub unsafe fn <a href='#method.from_raw' class='fnname'>from_raw</a>(ptr: *const T) -> Self</code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.17.0'>1.17.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#389-404' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Constructs an <code>Arc</code> from a raw pointer.</p>
<p>The raw pointer must have been previously returned by a call to a
<a href="struct.Arc.html#method.into_raw"><code>Arc::into_raw</code></a>.</p>
<p>This function is unsafe because improper use may lead to memory problems. For example, a
double-free may occur if the function is called twice on the same raw pointer.</p>
<h1 id="examples-4" class="section-header"><a href="#examples-4">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">10</span>);
<span class="kw">let</span> <span class="ident">x_ptr</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">into_raw</span>(<span class="ident">x</span>);
<span class="kw">unsafe</span> {
<span class="comment">// Convert back to an `Arc` to prevent leak.</span>
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">from_raw</span>(<span class="ident">x_ptr</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">x</span>, <span class="number">10</span>);
<span class="comment">// Further calls to `Arc::from_raw(x_ptr)` would be memory unsafe.</span>
}
<span class="comment">// The memory was freed when `x` went out of scope above, so `x_ptr` is now dangling!</span></pre>
</div><h4 id='method.downgrade' class="method"><span id='downgrade.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.downgrade' class='fnname'>downgrade</a>(this: &Self) -> <a class="struct" href="../../alloc/arc/struct.Weak.html" title="struct alloc::arc::Weak">Weak</a><T></code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.4.0'>1.4.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#420-444' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Creates a new <a href="struct.Weak.html"><code>Weak</code></a> pointer to this value.</p>
<h1 id="examples-5" class="section-header"><a href="#examples-5">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="kw">let</span> <span class="ident">weak_five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">downgrade</span>(<span class="kw-2">&</span><span class="ident">five</span>);</pre>
</div><h4 id='method.weak_count' class="method"><span id='weak_count.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.weak_count' class='fnname'>weak_count</a>(this: &Self) -> usize</code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.15.0'>1.15.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#470-475' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Gets the number of <a href="struct.Weak.html"><code>Weak</code></a> pointers to this value.</p>
<h1 id="safety" class="section-header"><a href="#safety">Safety</a></h1>
<p>This method by itself is safe, but using it correctly requires extra care.
Another thread can change the weak count at any time,
including potentially between calling this method and acting on the result.</p>
<h1 id="examples-6" class="section-header"><a href="#examples-6">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="kw">let</span> <span class="ident">_weak_five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">downgrade</span>(<span class="kw-2">&</span><span class="ident">five</span>);
<span class="comment">// This assertion is deterministic because we haven't shared</span>
<span class="comment">// the `Arc` or `Weak` between threads.</span>
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">1</span>, <span class="ident">Arc</span>::<span class="ident">weak_count</span>(<span class="kw-2">&</span><span class="ident">five</span>));</pre>
</div><h4 id='method.strong_count' class="method"><span id='strong_count.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.strong_count' class='fnname'>strong_count</a>(this: &Self) -> usize</code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.15.0'>1.15.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#499-501' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Gets the number of strong (<code>Arc</code>) pointers to this value.</p>
<h1 id="safety-1" class="section-header"><a href="#safety-1">Safety</a></h1>
<p>This method by itself is safe, but using it correctly requires extra care.
Another thread can change the strong count at any time,
including potentially between calling this method and acting on the result.</p>
<h1 id="examples-7" class="section-header"><a href="#examples-7">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="kw">let</span> <span class="ident">_also_five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">five</span>);
<span class="comment">// This assertion is deterministic because we haven't shared</span>
<span class="comment">// the `Arc` between threads.</span>
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">2</span>, <span class="ident">Arc</span>::<span class="ident">strong_count</span>(<span class="kw-2">&</span><span class="ident">five</span>));</pre>
</div><h4 id='method.ptr_eq' class="method"><span id='ptr_eq.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.ptr_eq' class='fnname'>ptr_eq</a>(this: &Self, other: &Self) -> bool</code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.17.0'>1.17.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#543-545' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Returns true if the two <code>Arc</code>s point to the same value (not
just values that compare as equal).</p>
<h1 id="examples-8" class="section-header"><a href="#examples-8">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="kw">let</span> <span class="ident">same_five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">five</span>);
<span class="kw">let</span> <span class="ident">other_five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">Arc</span>::<span class="ident">ptr_eq</span>(<span class="kw-2">&</span><span class="ident">five</span>, <span class="kw-2">&</span><span class="ident">same_five</span>));
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="ident">Arc</span>::<span class="ident">ptr_eq</span>(<span class="kw-2">&</span><span class="ident">five</span>, <span class="kw-2">&</span><span class="ident">other_five</span>));</pre>
</div></div><h3 id='impl-2' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: <a class="trait" href="../../core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-2' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#744-827' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.make_mut' class="method"><span id='make_mut.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.make_mut' class='fnname'>make_mut</a>(this: &mut Self) -> &mut T</code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.4.0'>1.4.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#776-826' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Makes a mutable reference into the given <code>Arc</code>.</p>
<p>If there are other <code>Arc</code> or <a href="struct.Weak.html"><code>Weak</code></a> pointers to the same value,
then <code>make_mut</code> will invoke <a href="../../std/clone/trait.Clone.html#tymethod.clone"><code>clone</code></a> on the inner value to
ensure unique ownership. This is also referred to as clone-on-write.</p>
<p>See also <a href="struct.Arc.html#method.get_mut"><code>get_mut</code></a>, which will fail rather than cloning.</p>
<h1 id="examples-9" class="section-header"><a href="#examples-9">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">data</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="kw-2">*</span><span class="ident">Arc</span>::<span class="ident">make_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">data</span>) <span class="op">+=</span> <span class="number">1</span>; <span class="comment">// Won't clone anything</span>
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">other_data</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">data</span>); <span class="comment">// Won't clone inner data</span>
<span class="kw-2">*</span><span class="ident">Arc</span>::<span class="ident">make_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">data</span>) <span class="op">+=</span> <span class="number">1</span>; <span class="comment">// Clones inner data</span>
<span class="kw-2">*</span><span class="ident">Arc</span>::<span class="ident">make_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">data</span>) <span class="op">+=</span> <span class="number">1</span>; <span class="comment">// Won't clone anything</span>
<span class="kw-2">*</span><span class="ident">Arc</span>::<span class="ident">make_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">other_data</span>) <span class="op">*=</span> <span class="number">2</span>; <span class="comment">// Won't clone anything</span>
<span class="comment">// Now `data` and `other_data` point to different values.</span>
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">data</span>, <span class="number">8</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">other_data</span>, <span class="number">12</span>);</pre>
</div></div><h3 id='impl-3' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-3' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#829-899' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.get_mut' class="method"><span id='get_mut.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.get_mut' class='fnname'>get_mut</a>(this: &mut Self) -> <a class="enum" href="../../core/option/enum.Option.html" title="enum core::option::Option">Option</a><&mut T></code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.4.0'>1.4.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#858-871' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Returns a mutable reference to the inner value, if there are
no other <code>Arc</code> or <a href="struct.Weak.html"><code>Weak</code></a> pointers to the same value.</p>
<p>Returns <a href="../../std/option/enum.Option.html"><code>None</code></a> otherwise, because it is not safe to
mutate a shared value.</p>
<p>See also <a href="struct.Arc.html#method.make_mut"><code>make_mut</code></a>, which will <a href="../../std/clone/trait.Clone.html#tymethod.clone"><code>clone</code></a>
the inner value when it's shared.</p>
<h1 id="examples-10" class="section-header"><a href="#examples-10">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">3</span>);
<span class="kw-2">*</span><span class="ident">Arc</span>::<span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">x</span>).<span class="ident">unwrap</span>() <span class="op">=</span> <span class="number">4</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">x</span>, <span class="number">4</span>);
<span class="kw">let</span> <span class="ident">_y</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">x</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">Arc</span>::<span class="ident">get_mut</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="ident">x</span>).<span class="ident">is_none</span>());</pre>
</div></div><h3 id='impl-4' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><<a class="trait" href="../../core/any/trait.Any.html" title="trait core::any::Any">Any</a> + <a class="trait" href="../../core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> + <a class="trait" href="../../core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a>></code><a href='#impl-4' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#975-1011' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.downcast' class="method"><span id='downcast.v' class='invisible'><table class='table-display'><tbody><tr><td><code>pub fn <a href='#method.downcast' class='fnname'>downcast</a><T>(self) -> <a class="enum" href="../../core/result/enum.Result.html" title="enum core::result::Result">Result</a><<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>, Self> <span class="where fmt-newline">where<br> T: <a class="trait" href="../../core/any/trait.Any.html" title="trait core::any::Any">Any</a> + <a class="trait" href="../../core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> + <a class="trait" href="../../core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> + 'static, </span></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#999-1010' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>rc_downcast </code><a href="https://github.com/rust-lang/rust/issues/44608">#44608</a>)</div></div><div class='docblock'><p>Attempt to downcast the <code>Arc<Any + Send + Sync></code> to a concrete type.</p>
<h1 id="examples-11" class="section-header"><a href="#examples-11">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="attribute">#![<span class="ident">feature</span>(<span class="ident">rc_downcast</span>)]</span>
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">any</span>::<span class="ident">Any</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">fn</span> <span class="ident">print_if_string</span>(<span class="ident">value</span>: <span class="ident">Arc</span><span class="op"><</span><span class="ident">Any</span> <span class="op">+</span> <span class="ident">Send</span> <span class="op">+</span> <span class="ident">Sync</span><span class="op">></span>) {
<span class="kw">if</span> <span class="kw">let</span> <span class="prelude-val">Ok</span>(<span class="ident">string</span>) <span class="op">=</span> <span class="ident">value</span>.<span class="ident">downcast</span>::<span class="op"><</span><span class="ident">String</span><span class="op">></span>() {
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"String ({}): {}"</span>, <span class="ident">string</span>.<span class="ident">len</span>(), <span class="ident">string</span>);
}
}
<span class="kw">fn</span> <span class="ident">main</span>() {
<span class="kw">let</span> <span class="ident">my_string</span> <span class="op">=</span> <span class="string">"Hello World"</span>.<span class="ident">to_string</span>();
<span class="ident">print_if_string</span>(<span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">my_string</span>));
<span class="ident">print_if_string</span>(<span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">0i8</span>));
}</pre>
</div></div>
<h2 id='implementations' class='small-section-header'>
Trait Implementations<a href='#implementations' class='anchor'></a>
</h2>
<div id='implementations-list'><h3 id='impl-From%3CArc%3CT%3E%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T> <a class="trait" href="../../core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>> for <a class="struct" href="../../alloc/task/struct.Waker.html" title="struct alloc::task::Waker">Waker</a> <span class="where fmt-newline">where<br> T: <a class="trait" href="../../alloc/task/trait.Wake.html" title="trait alloc::task::Wake">Wake</a> + 'static, </span></code><a href='#impl-From%3CArc%3CT%3E%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/task.rs.html#81-90' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.from' class="method"><span id='from.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(rc: <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> Self</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/task.rs.html#84-89' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-Send' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> + <a class="trait" href="../../core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>> <a class="trait" href="../../core/marker/trait.Send.html" title="trait core::marker::Send">Send</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Send' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#206' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'></div><h3 id='impl-Sync' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> + <a class="trait" href="../../core/marker/trait.Send.html" title="trait core::marker::Send">Send</a>> <a class="trait" href="../../core/marker/trait.Sync.html" title="trait core::marker::Sync">Sync</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Sync' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#208' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'></div><h3 id='impl-CoerceUnsized%3CArc%3CU%3E%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../core/marker/trait.Unsize.html" title="trait core::marker::Unsize">Unsize</a><U>, U: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../core/ops/unsize/trait.CoerceUnsized.html" title="trait core::ops::unsize::CoerceUnsized">CoerceUnsized</a><<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><U>> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-CoerceUnsized%3CArc%3CU%3E%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#211' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'></div><h3 id='impl-Clone' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Clone' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#685-732' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.clone' class="method"><span id='clone.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#701-731' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Makes a clone of the <code>Arc</code> pointer.</p>
<p>This creates another pointer to the same inner value, increasing the
strong reference count.</p>
<h1 id="examples-12" class="section-header"><a href="#examples-12">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">five</span>);</pre>
</div><h4 id='method.clone_from' class="method"><span id='clone_from.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, source: &Self)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/core/clone.rs.html#130-132' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="../../core/clone/trait.Clone.html#method.clone_from">Read more</a></p>
</div></div><h3 id='impl-Deref' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../core/ops/deref/trait.Deref.html" title="trait core::ops::deref::Deref">Deref</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Deref' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#735-742' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='associatedtype.Target' class="type"><span id='Target.t' class='invisible'><code>type <a href='../../core/ops/deref/trait.Deref.html#associatedtype.Target' class="type">Target</a> = T</code></span></h4>
<div class='docblock'><p>The resulting type after dereferencing.</p>
</div><h4 id='method.deref' class="method"><span id='deref.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/ops/deref/trait.Deref.html#tymethod.deref' class='fnname'>deref</a>(&self) -> &T</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#739-741' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Dereferences the value.</p>
</div></div><h3 id='impl-Drop' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../core/ops/drop/trait.Drop.html" title="trait core::ops::drop::Drop">Drop</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Drop' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#902-973' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.drop' class="method"><span id='drop.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/ops/drop/trait.Drop.html#tymethod.drop' class='fnname'>drop</a>(&mut self)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#931-972' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Drops the <code>Arc</code>.</p>
<p>This will decrement the strong reference count. If the strong reference
count reaches zero then the only other references (if any) are
<a href="struct.Weak.html"><code>Weak</code></a>, so we <code>drop</code> the inner value.</p>
<h1 id="examples-13" class="section-header"><a href="#examples-13">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">struct</span> <span class="ident">Foo</span>;
<span class="kw">impl</span> <span class="ident">Drop</span> <span class="kw">for</span> <span class="ident">Foo</span> {
<span class="kw">fn</span> <span class="ident">drop</span>(<span class="kw-2">&</span><span class="kw-2">mut</span> <span class="self">self</span>) {
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"dropped!"</span>);
}
}
<span class="kw">let</span> <span class="ident">foo</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="ident">Foo</span>);
<span class="kw">let</span> <span class="ident">foo2</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">clone</span>(<span class="kw-2">&</span><span class="ident">foo</span>);
<span class="ident">drop</span>(<span class="ident">foo</span>); <span class="comment">// Doesn't print anything</span>
<span class="ident">drop</span>(<span class="ident">foo2</span>); <span class="comment">// Prints "dropped!"</span></pre>
</div></div><h3 id='impl-PartialEq' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a>> <a class="trait" href="../../core/cmp/trait.PartialEq.html" title="trait core::cmp::PartialEq">PartialEq</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-PartialEq' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1206-1240' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.eq' class="method"><span id='eq.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> bool</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1220-1222' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Equality for two <code>Arc</code>s.</p>
<p>Two <code>Arc</code>s are equal if their inner values are equal.</p>
<h1 id="examples-14" class="section-header"><a href="#examples-14">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">five</span> <span class="op">==</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>));</pre>
</div><h4 id='method.ne' class="method"><span id='ne.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> bool</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1237-1239' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Inequality for two <code>Arc</code>s.</p>
<p>Two <code>Arc</code>s are unequal if their inner values are unequal.</p>
<h1 id="examples-15" class="section-header"><a href="#examples-15">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">five</span> <span class="op">!=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">6</span>));</pre>
</div></div><h3 id='impl-PartialOrd' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../core/cmp/trait.PartialOrd.html" title="trait core::cmp::PartialOrd">PartialOrd</a>> <a class="trait" href="../../core/cmp/trait.PartialOrd.html" title="trait core::cmp::PartialOrd">PartialOrd</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-PartialOrd' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1242-1328' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.partial_cmp' class="method"><span id='partial_cmp.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.PartialOrd.html#tymethod.partial_cmp' class='fnname'>partial_cmp</a>(&self, other: &<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> <a class="enum" href="../../core/option/enum.Option.html" title="enum core::option::Option">Option</a><<a class="enum" href="../../core/cmp/enum.Ordering.html" title="enum core::cmp::Ordering">Ordering</a>></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1257-1259' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Partial comparison for two <code>Arc</code>s.</p>
<p>The two are compared by calling <code>partial_cmp()</code> on their inner values.</p>
<h1 id="examples-16" class="section-header"><a href="#examples-16">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cmp</span>::<span class="ident">Ordering</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="prelude-val">Some</span>(<span class="ident">Ordering</span>::<span class="ident">Less</span>), <span class="ident">five</span>.<span class="ident">partial_cmp</span>(<span class="kw-2">&</span><span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">6</span>)));</pre>
</div><h4 id='method.lt' class="method"><span id='lt.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.PartialOrd.html#method.lt' class='fnname'>lt</a>(&self, other: &<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> bool</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1274-1276' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Less-than comparison for two <code>Arc</code>s.</p>
<p>The two are compared by calling <code><</code> on their inner values.</p>
<h1 id="examples-17" class="section-header"><a href="#examples-17">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">five</span> <span class="op"><</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">6</span>));</pre>
</div><h4 id='method.le' class="method"><span id='le.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.PartialOrd.html#method.le' class='fnname'>le</a>(&self, other: &<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> bool</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1291-1293' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>'Less than or equal to' comparison for two <code>Arc</code>s.</p>
<p>The two are compared by calling <code><=</code> on their inner values.</p>
<h1 id="examples-18" class="section-header"><a href="#examples-18">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">five</span> <span class="op"><=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>));</pre>
</div><h4 id='method.gt' class="method"><span id='gt.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.PartialOrd.html#method.gt' class='fnname'>gt</a>(&self, other: &<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> bool</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1308-1310' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Greater-than comparison for two <code>Arc</code>s.</p>
<p>The two are compared by calling <code>></code> on their inner values.</p>
<h1 id="examples-19" class="section-header"><a href="#examples-19">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">five</span> <span class="op">></span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">4</span>));</pre>
</div><h4 id='method.ge' class="method"><span id='ge.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.PartialOrd.html#method.ge' class='fnname'>ge</a>(&self, other: &<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> bool</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1325-1327' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>'Greater than or equal to' comparison for two <code>Arc</code>s.</p>
<p>The two are compared by calling <code>>=</code> on their inner values.</p>
<h1 id="examples-20" class="section-header"><a href="#examples-20">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert</span><span class="macro">!</span>(<span class="ident">five</span> <span class="op">>=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>));</pre>
</div></div><h3 id='impl-Ord' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../core/cmp/trait.Ord.html" title="trait core::cmp::Ord">Ord</a>> <a class="trait" href="../../core/cmp/trait.Ord.html" title="trait core::cmp::Ord">Ord</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Ord' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1330-1348' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.cmp' class="method"><span id='cmp.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.Ord.html#tymethod.cmp' class='fnname'>cmp</a>(&self, other: &<a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T>) -> <a class="enum" href="../../core/cmp/enum.Ordering.html" title="enum core::cmp::Ordering">Ordering</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1345-1347' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Comparison for two <code>Arc</code>s.</p>
<p>The two are compared by calling <code>cmp()</code> on their inner values.</p>
<h1 id="examples-21" class="section-header"><a href="#examples-21">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">cmp</span>::<span class="ident">Ordering</span>;
<span class="kw">let</span> <span class="ident">five</span> <span class="op">=</span> <span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">5</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">Ordering</span>::<span class="ident">Less</span>, <span class="ident">five</span>.<span class="ident">cmp</span>(<span class="kw-2">&</span><span class="ident">Arc</span>::<span class="ident">new</span>(<span class="number">6</span>)));</pre>
</div><h4 id='method.max' class="method"><span id='max.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.Ord.html#method.max' class='fnname'>max</a>(self, other: Self) -> Self</code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../../src/core/cmp.rs.html#469-472' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Compares and returns the maximum of two values. <a href="../../core/cmp/trait.Ord.html#method.max">Read more</a></p>
</div><h4 id='method.min' class="method"><span id='min.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/cmp/trait.Ord.html#method.min' class='fnname'>min</a>(self, other: Self) -> Self</code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../../src/core/cmp.rs.html#485-488' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Compares and returns the minimum of two values. <a href="../../core/cmp/trait.Ord.html#method.min">Read more</a></p>
</div></div><h3 id='impl-Eq' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a>> <a class="trait" href="../../core/cmp/trait.Eq.html" title="trait core::cmp::Eq">Eq</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Eq' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1350' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'></div><h3 id='impl-Display' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../alloc/fmt/trait.Display.html" title="trait alloc::fmt::Display">Display</a>> <a class="trait" href="../../alloc/fmt/trait.Display.html" title="trait alloc::fmt::Display">Display</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Display' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1353-1357' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../alloc/fmt/trait.Display.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../../alloc/fmt/struct.Formatter.html" title="struct alloc::fmt::Formatter">Formatter</a>) -> <a class="type" href="../../alloc/fmt/type.Result.html" title="type alloc::fmt::Result">Result</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1354-1356' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Formats the value using the given formatter. <a href="../../alloc/fmt/trait.Display.html#tymethod.fmt">Read more</a></p>
</div></div><h3 id='impl-Debug' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../alloc/fmt/trait.Debug.html" title="trait alloc::fmt::Debug">Debug</a>> <a class="trait" href="../../alloc/fmt/trait.Debug.html" title="trait alloc::fmt::Debug">Debug</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Debug' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1360-1364' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.fmt-1' class="method"><span id='fmt.v-1' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../alloc/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../../alloc/fmt/struct.Formatter.html" title="struct alloc::fmt::Formatter">Formatter</a>) -> <a class="type" href="../../alloc/fmt/type.Result.html" title="type alloc::fmt::Result">Result</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1361-1363' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Formats the value using the given formatter. <a href="../../alloc/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></div><h3 id='impl-Pointer' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../alloc/fmt/trait.Pointer.html" title="trait alloc::fmt::Pointer">Pointer</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Pointer' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1367-1371' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.fmt-2' class="method"><span id='fmt.v-2' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../alloc/fmt/trait.Pointer.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../../alloc/fmt/struct.Formatter.html" title="struct alloc::fmt::Formatter">Formatter</a>) -> <a class="type" href="../../alloc/fmt/type.Result.html" title="type alloc::fmt::Result">Result</a></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1368-1370' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 id='impl-Default' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: <a class="trait" href="../../core/default/trait.Default.html" title="trait core::default::Default">Default</a>> <a class="trait" href="../../core/default/trait.Default.html" title="trait core::default::Default">Default</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Default' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1374-1388' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.default' class="method"><span id='default.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/default/trait.Default.html#tymethod.default' class='fnname'>default</a>() -> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1385-1387' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Creates a new <code>Arc<T></code>, with the <code>Default</code> value for <code>T</code>.</p>
<h1 id="examples-22" class="section-header"><a href="#examples-22">Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">sync</span>::<span class="ident">Arc</span>;
<span class="kw">let</span> <span class="ident">x</span>: <span class="ident">Arc</span><span class="op"><</span><span class="ident">i32</span><span class="op">></span> <span class="op">=</span> <span class="ident">Default</span>::<span class="ident">default</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="kw-2">*</span><span class="ident">x</span>, <span class="number">0</span>);</pre>
</div></div><h3 id='impl-Hash' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a> + <a class="trait" href="../../core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a>> <a class="trait" href="../../core/hash/trait.Hash.html" title="trait core::hash::Hash">Hash</a> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Hash' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1391-1395' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.hash' class="method"><span id='hash.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a><H: <a class="trait" href="../../core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>>(&self, state: &mut H)</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1392-1394' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Feeds this value into the given [<code>Hasher</code>]. <a href="../../core/hash/trait.Hash.html#tymethod.hash">Read more</a></p>
</div><h4 id='method.hash_slice' class="method"><span id='hash_slice.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/hash/trait.Hash.html#method.hash_slice' class='fnname'>hash_slice</a><H>(data: &[Self], state: &mut H) <span class="where fmt-newline">where<br> H: <a class="trait" href="../../core/hash/trait.Hasher.html" title="trait core::hash::Hasher">Hasher</a>, </span></code></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.3.0'>1.3.0</div><a class='srclink' href='../../src/core/hash/mod.rs.html#203-209' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Feeds a slice of this type into the given [<code>Hasher</code>]. <a href="../../core/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
</div></div><h3 id='impl-From%3CT%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T> <a class="trait" href="../../core/convert/trait.From.html" title="trait core::convert::From">From</a><T> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-From%3CT%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.6.0'>1.6.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#1398-1402' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.from-1' class="method"><span id='from.v-1' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(t: T) -> Self</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1399-1401' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3C%26%27a%20%5BT%5D%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<'a, T: <a class="trait" href="../../core/clone/trait.Clone.html" title="trait core::clone::Clone">Clone</a>> <a class="trait" href="../../core/convert/trait.From.html" title="trait core::convert::From">From</a><&'a [T]> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><[T]></code><a href='#impl-From%3C%26%27a%20%5BT%5D%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#1405-1410' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.from-2' class="method"><span id='from.v-2' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(v: &[T]) -> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><[T]></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1407-1409' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3C%26%27a%20str%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<'a> <a class="trait" href="../../core/convert/trait.From.html" title="trait core::convert::From">From</a><&'a str> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><str></code><a href='#impl-From%3C%26%27a%20str%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#1413-1419' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.from-3' class="method"><span id='from.v-3' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(v: &str) -> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><str></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1415-1418' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3CString%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl <a class="trait" href="../../core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="../../alloc/string/struct.String.html" title="struct alloc::string::String">String</a>> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><str></code><a href='#impl-From%3CString%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#1422-1427' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.from-4' class="method"><span id='from.v-4' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(v: <a class="struct" href="../../alloc/string/struct.String.html" title="struct alloc::string::String">String</a>) -> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><str></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1424-1426' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3CBox%3CT%3E%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="../../alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><T>> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-From%3CBox%3CT%3E%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#1430-1435' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.from-5' class="method"><span id='from.v-5' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(v: <a class="struct" href="../../alloc/boxed/struct.Box.html" title="struct alloc::boxed::Box">Box</a><T>) -> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1432-1434' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3CVec%3CT%3E%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T> <a class="trait" href="../../core/convert/trait.From.html" title="trait core::convert::From">From</a><<a class="struct" href="../../alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><T>> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><[T]></code><a href='#impl-From%3CVec%3CT%3E%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#1438-1450' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.from-6' class="method"><span id='from.v-6' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(v: <a class="struct" href="../../alloc/vec/struct.Vec.html" title="struct alloc::vec::Vec">Vec</a><T>) -> <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><[T]></code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1440-1449' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-Borrow%3CT%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../alloc/borrow/trait.Borrow.html" title="trait alloc::borrow::Borrow">Borrow</a><T> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-Borrow%3CT%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1909-1913' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.borrow' class="method"><span id='borrow.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../alloc/borrow/trait.Borrow.html#tymethod.borrow' class='fnname'>borrow</a>(&self) -> &T</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1910-1912' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Immutably borrows from an owned value. <a href="../../alloc/borrow/trait.Borrow.html#tymethod.borrow">Read more</a></p>
</div></div><h3 id='impl-AsRef%3CT%3E' class='impl'><span class='in-band'><table class='table-display'><tbody><tr><td><code>impl<T: ?<a class="trait" href="../../core/marker/trait.Sized.html" title="trait core::marker::Sized">Sized</a>> <a class="trait" href="../../core/convert/trait.AsRef.html" title="trait core::convert::AsRef">AsRef</a><T> for <a class="struct" href="../../alloc/arc/struct.Arc.html" title="struct alloc::arc::Arc">Arc</a><T></code><a href='#impl-AsRef%3CT%3E' class='anchor'></a></span></td><td><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.5.0'>1.5.0</div><a class='srclink' href='../../src/alloc/arc.rs.html#1916-1920' title='goto source code'>[src]</a></span></td></tr></tbody></table></h3><div class='impl-items'><h4 id='method.as_ref' class="method"><span id='as_ref.v' class='invisible'><table class='table-display'><tbody><tr><td><code>fn <a href='../../core/convert/trait.AsRef.html#tymethod.as_ref' class='fnname'>as_ref</a>(&self) -> &T</code></span></td><td><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../../src/alloc/arc.rs.html#1917-1919' title='goto source code'>[src]</a></td></tr></tbody></table></span></h4><div class='docblock'><p>Performs the conversion.</p>
</div></div></div></section><section id="search" class="content hidden"></section><section class="footer"></section><aside id="help" class="hidden"><div><h1 class="hidden">Help</h1><div class="shortcuts"><h2>Keyboard Shortcuts</h2><dl><dt><kbd>?</kbd></dt><dd>Show this help dialog</dd><dt><kbd>S</kbd></dt><dd>Focus the search field</dd><dt><kbd>↑</kbd></dt><dd>Move up in search results</dd><dt><kbd>↓</kbd></dt><dd>Move down in search results</dd><dt><kbd>↹</kbd></dt><dd>Switch tab</dd><dt><kbd>⏎</kbd></dt><dd>Go to active search result</dd><dt><kbd>+</kbd></dt><dd>Expand all sections</dd><dt><kbd>-</kbd></dt><dd>Collapse all sections</dd></dl></div><div class="infos"><h2>Search Tricks</h2><p>Prefix searches with a type followed by a colon (e.g. <code>fn:</code>) to restrict the search to a given type.</p><p>Accepted types are: <code>fn</code>, <code>mod</code>, <code>struct</code>, <code>enum</code>, <code>trait</code>, <code>type</code>, <code>macro</code>, and <code>const</code>.</p><p>Search functions by type signature (e.g. <code>vec -> usize</code> or <code>* -> vec</code>)</p><p>Search multiple things at once by splitting your query with comma (e.g. <code>str,u8</code> or <code>String,struct:Vec,test</code>)</p></div></div></aside><script>window.rootPath = "../../";window.currentCrate = "alloc";</script><script src="../../aliases.js"></script><script src="../../main.js"></script><script defer src="../../search-index.js"></script></body></html>
distrib
>
Mageia
>
6
>
armv7hl
>
media
>
core-updates
>
by-pkgid
>
4e2dbb669434a7691662cb2f0ad38972
>
files
>
59
