178 lines
26 KiB
HTML
178 lines
26 KiB
HTML
<!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 `ops` mod in crate `nom`."><meta name="keywords" content="rust, rustlang, rust-lang, ops"><title>nom::lib::std::ops - 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><noscript><link rel="stylesheet" href="../../../../noscript.css"></noscript><link rel="shortcut icon" href="../../../../favicon.ico"><style type="text/css">#crate-search{background-image:url("../../../../down-arrow.svg");}</style></head><body class="rustdoc mod"><!--[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='../../../../nom/index.html'><div class='logo-container'><img src='../../../../rust-logo.png' alt='logo'></div></a><p class='location'>Module ops</p><div class="sidebar-elems"><div class="block items"><ul><li><a href="#structs">Structs</a></li><li><a href="#enums">Enums</a></li><li><a href="#traits">Traits</a></li></ul></div><p class='location'><a href='../../../index.html'>nom</a>::<wbr><a href='../../index.html'>lib</a>::<wbr><a href='../index.html'>std</a></p><script>window.sidebarCurrent = {name: 'ops', ty: 'mod', 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"><div class="search-container"><div><select id="crate-search"><option value="All crates">All crates</option></select><input class="search-input" name="search" disabled autocomplete="off" spellcheck="false" placeholder="Click or press ‘S’ to search, ‘?’ for more options…" type="search"></div><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='out-of-band'><span class='since' title='Stable since Rust version 1.0.0'>1.0.0</span><span id='render-detail'><a id="toggle-all-docs" href="javascript:void(0)" title="collapse all docs">[<span class='inner'>−</span>]</a></span><a class='srclink' href='https://doc.rust-lang.org/nightly/src/core/lib.rs.html#217' title='goto source code'>[src]</a></span><span class='in-band'>Module <a href='../../../index.html'>nom</a>::<wbr><a href='../../index.html'>lib</a>::<wbr><a href='../index.html'>std</a>::<wbr><a class="mod" href=''>ops</a></span></h1><div class='docblock'><p>Overloadable operators.</p>
|
||
<p>Implementing these traits allows you to overload certain operators.</p>
|
||
<p>Some of these traits are imported by the prelude, so they are available in
|
||
every Rust program. Only operators backed by traits can be overloaded. For
|
||
example, the addition operator (<code>+</code>) can be overloaded through the <a href="trait.Add.html"><code>Add</code></a>
|
||
trait, but since the assignment operator (<code>=</code>) has no backing trait, there
|
||
is no way of overloading its semantics. Additionally, this module does not
|
||
provide any mechanism to create new operators. If traitless overloading or
|
||
custom operators are required, you should look toward macros or compiler
|
||
plugins to extend Rust's syntax.</p>
|
||
<p>Implementations of operator traits should be unsurprising in their
|
||
respective contexts, keeping in mind their usual meanings and
|
||
<a href="../../reference/expressions.html#expression-precedence">operator precedence</a>. For example, when implementing <a href="trait.Mul.html"><code>Mul</code></a>, the operation
|
||
should have some resemblance to multiplication (and share expected
|
||
properties like associativity).</p>
|
||
<p>Note that the <code>&&</code> and <code>||</code> operators short-circuit, i.e., they only
|
||
evaluate their second operand if it contributes to the result. Since this
|
||
behavior is not enforceable by traits, <code>&&</code> and <code>||</code> are not supported as
|
||
overloadable operators.</p>
|
||
<p>Many of the operators take their operands by value. In non-generic
|
||
contexts involving built-in types, this is usually not a problem.
|
||
However, using these operators in generic code, requires some
|
||
attention if values have to be reused as opposed to letting the operators
|
||
consume them. One option is to occasionally use <a href="../clone/trait.Clone.html#tymethod.clone"><code>clone</code></a>.
|
||
Another option is to rely on the types involved providing additional
|
||
operator implementations for references. For example, for a user-defined
|
||
type <code>T</code> which is supposed to support addition, it is probably a good
|
||
idea to have both <code>T</code> and <code>&T</code> implement the traits <a href="trait.Add.html"><code>Add<T></code></a> and
|
||
<a href="trait.Add.html"><code>Add<&T></code></a> so that generic code can be written without unnecessary
|
||
cloning.</p>
|
||
<h1 id="examples" class="section-header"><a href="#examples">Examples</a></h1>
|
||
<p>This example creates a <code>Point</code> struct that implements <a href="trait.Add.html"><code>Add</code></a> and <a href="trait.Sub.html"><code>Sub</code></a>,
|
||
and then demonstrates adding and subtracting two <code>Point</code>s.</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">ops</span>::{<span class="ident">Add</span>, <span class="ident">Sub</span>};
|
||
|
||
<span class="attribute">#[<span class="ident">derive</span>(<span class="ident">Debug</span>, <span class="ident">PartialEq</span>)]</span>
|
||
<span class="kw">struct</span> <span class="ident">Point</span> {
|
||
<span class="ident">x</span>: <span class="ident">i32</span>,
|
||
<span class="ident">y</span>: <span class="ident">i32</span>,
|
||
}
|
||
|
||
<span class="kw">impl</span> <span class="ident">Add</span> <span class="kw">for</span> <span class="ident">Point</span> {
|
||
<span class="kw">type</span> <span class="ident">Output</span> <span class="op">=</span> <span class="ident">Point</span>;
|
||
|
||
<span class="kw">fn</span> <span class="ident">add</span>(<span class="self">self</span>, <span class="ident">other</span>: <span class="ident">Point</span>) <span class="op">-</span><span class="op">></span> <span class="ident">Point</span> {
|
||
<span class="ident">Point</span> {<span class="ident">x</span>: <span class="self">self</span>.<span class="ident">x</span> <span class="op">+</span> <span class="ident">other</span>.<span class="ident">x</span>, <span class="ident">y</span>: <span class="self">self</span>.<span class="ident">y</span> <span class="op">+</span> <span class="ident">other</span>.<span class="ident">y</span>}
|
||
}
|
||
}
|
||
|
||
<span class="kw">impl</span> <span class="ident">Sub</span> <span class="kw">for</span> <span class="ident">Point</span> {
|
||
<span class="kw">type</span> <span class="ident">Output</span> <span class="op">=</span> <span class="ident">Point</span>;
|
||
|
||
<span class="kw">fn</span> <span class="ident">sub</span>(<span class="self">self</span>, <span class="ident">other</span>: <span class="ident">Point</span>) <span class="op">-</span><span class="op">></span> <span class="ident">Point</span> {
|
||
<span class="ident">Point</span> {<span class="ident">x</span>: <span class="self">self</span>.<span class="ident">x</span> <span class="op">-</span> <span class="ident">other</span>.<span class="ident">x</span>, <span class="ident">y</span>: <span class="self">self</span>.<span class="ident">y</span> <span class="op">-</span> <span class="ident">other</span>.<span class="ident">y</span>}
|
||
}
|
||
}
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">Point</span> {<span class="ident">x</span>: <span class="number">3</span>, <span class="ident">y</span>: <span class="number">3</span>}, <span class="ident">Point</span> {<span class="ident">x</span>: <span class="number">1</span>, <span class="ident">y</span>: <span class="number">0</span>} <span class="op">+</span> <span class="ident">Point</span> {<span class="ident">x</span>: <span class="number">2</span>, <span class="ident">y</span>: <span class="number">3</span>});
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">Point</span> {<span class="ident">x</span>: <span class="op">-</span><span class="number">1</span>, <span class="ident">y</span>: <span class="op">-</span><span class="number">3</span>}, <span class="ident">Point</span> {<span class="ident">x</span>: <span class="number">1</span>, <span class="ident">y</span>: <span class="number">0</span>} <span class="op">-</span> <span class="ident">Point</span> {<span class="ident">x</span>: <span class="number">2</span>, <span class="ident">y</span>: <span class="number">3</span>});</pre></div>
|
||
<p>See the documentation for each trait for an example implementation.</p>
|
||
<p>The <a href="trait.Fn.html"><code>Fn</code></a>, <a href="trait.FnMut.html"><code>FnMut</code></a>, and <a href="trait.FnOnce.html"><code>FnOnce</code></a> traits are implemented by types that can be
|
||
invoked like functions. Note that <a href="trait.Fn.html"><code>Fn</code></a> takes <code>&self</code>, <a href="trait.FnMut.html"><code>FnMut</code></a> takes <code>&mut self</code> and <a href="trait.FnOnce.html"><code>FnOnce</code></a> takes <code>self</code>. These correspond to the three kinds of
|
||
methods that can be invoked on an instance: call-by-reference,
|
||
call-by-mutable-reference, and call-by-value. The most common use of these
|
||
traits is to act as bounds to higher-level functions that take functions or
|
||
closures as arguments.</p>
|
||
<p>Taking a <a href="trait.Fn.html"><code>Fn</code></a> as a parameter:</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">fn</span> <span class="ident">call_with_one</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="ident">func</span>: <span class="ident">F</span>) <span class="op">-</span><span class="op">></span> <span class="ident">usize</span>
|
||
<span class="kw">where</span> <span class="ident">F</span>: <span class="ident">Fn</span>(<span class="ident">usize</span>) <span class="op">-</span><span class="op">></span> <span class="ident">usize</span>
|
||
{
|
||
<span class="ident">func</span>(<span class="number">1</span>)
|
||
}
|
||
|
||
<span class="kw">let</span> <span class="ident">double</span> <span class="op">=</span> <span class="op">|</span><span class="ident">x</span><span class="op">|</span> <span class="ident">x</span> <span class="op">*</span> <span class="number">2</span>;
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">call_with_one</span>(<span class="ident">double</span>), <span class="number">2</span>);</pre></div>
|
||
<p>Taking a <a href="trait.FnMut.html"><code>FnMut</code></a> as a parameter:</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">fn</span> <span class="ident">do_twice</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="kw-2">mut</span> <span class="ident">func</span>: <span class="ident">F</span>)
|
||
<span class="kw">where</span> <span class="ident">F</span>: <span class="ident">FnMut</span>()
|
||
{
|
||
<span class="ident">func</span>();
|
||
<span class="ident">func</span>();
|
||
}
|
||
|
||
<span class="kw">let</span> <span class="kw-2">mut</span> <span class="ident">x</span>: <span class="ident">usize</span> <span class="op">=</span> <span class="number">1</span>;
|
||
{
|
||
<span class="kw">let</span> <span class="ident">add_two_to_x</span> <span class="op">=</span> <span class="op">|</span><span class="op">|</span> <span class="ident">x</span> <span class="op">+</span><span class="op">=</span> <span class="number">2</span>;
|
||
<span class="ident">do_twice</span>(<span class="ident">add_two_to_x</span>);
|
||
}
|
||
|
||
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>, <span class="number">5</span>);</pre></div>
|
||
<p>Taking a <a href="trait.FnOnce.html"><code>FnOnce</code></a> as a parameter:</p>
|
||
|
||
<div class="example-wrap"><pre class="rust rust-example-rendered">
|
||
<span class="kw">fn</span> <span class="ident">consume_with_relish</span><span class="op"><</span><span class="ident">F</span><span class="op">></span>(<span class="ident">func</span>: <span class="ident">F</span>)
|
||
<span class="kw">where</span> <span class="ident">F</span>: <span class="ident">FnOnce</span>() <span class="op">-</span><span class="op">></span> <span class="ident">String</span>
|
||
{
|
||
<span class="comment">// `func` consumes its captured variables, so it cannot be run more</span>
|
||
<span class="comment">// than once</span>
|
||
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"Consumed: {}"</span>, <span class="ident">func</span>());
|
||
|
||
<span class="macro">println</span><span class="macro">!</span>(<span class="string">"Delicious!"</span>);
|
||
|
||
<span class="comment">// Attempting to invoke `func()` again will throw a `use of moved</span>
|
||
<span class="comment">// value` error for `func`</span>
|
||
}
|
||
|
||
<span class="kw">let</span> <span class="ident">x</span> <span class="op">=</span> <span class="ident">String</span>::<span class="ident">from</span>(<span class="string">"x"</span>);
|
||
<span class="kw">let</span> <span class="ident">consume_and_return_x</span> <span class="op">=</span> <span class="kw">move</span> <span class="op">|</span><span class="op">|</span> <span class="ident">x</span>;
|
||
<span class="ident">consume_with_relish</span>(<span class="ident">consume_and_return_x</span>);
|
||
|
||
<span class="comment">// `consume_and_return_x` can no longer be invoked at this point</span></pre></div>
|
||
</div><h2 id='structs' class='section-header'><a href="#structs">Structs</a></h2>
|
||
<table><tr class='module-item'><td><a class="struct" href="struct.Range.html" title='nom::lib::std::ops::Range struct'>Range</a></td><td class='docblock-short'><p>A (half-open) range bounded inclusively below and exclusively above
|
||
(<code>start..end</code>).</p>
|
||
</td></tr><tr class='module-item'><td><a class="struct" href="struct.RangeFrom.html" title='nom::lib::std::ops::RangeFrom struct'>RangeFrom</a></td><td class='docblock-short'><p>A range only bounded inclusively below (<code>start..</code>).</p>
|
||
</td></tr><tr class='module-item'><td><a class="struct" href="struct.RangeFull.html" title='nom::lib::std::ops::RangeFull struct'>RangeFull</a></td><td class='docblock-short'><p>An unbounded range (<code>..</code>).</p>
|
||
</td></tr><tr class='module-item'><td><a class="struct" href="struct.RangeInclusive.html" title='nom::lib::std::ops::RangeInclusive struct'>RangeInclusive</a></td><td class='docblock-short'><p>A range bounded inclusively below and above (<code>start..=end</code>).</p>
|
||
</td></tr><tr class='module-item'><td><a class="struct" href="struct.RangeTo.html" title='nom::lib::std::ops::RangeTo struct'>RangeTo</a></td><td class='docblock-short'><p>A range only bounded exclusively above (<code>..end</code>).</p>
|
||
</td></tr><tr class='module-item'><td><a class="struct" href="struct.RangeToInclusive.html" title='nom::lib::std::ops::RangeToInclusive struct'>RangeToInclusive</a></td><td class='docblock-short'><p>A range only bounded inclusively above (<code>..=end</code>).</p>
|
||
</td></tr></table><h2 id='enums' class='section-header'><a href="#enums">Enums</a></h2>
|
||
<table><tr class='module-item'><td><a class="enum" href="enum.Bound.html" title='nom::lib::std::ops::Bound enum'>Bound</a></td><td class='docblock-short'><p>An endpoint of a range of keys.</p>
|
||
</td></tr><tr class='unstable module-item'><td><a class="enum" href="enum.GeneratorState.html" title='nom::lib::std::ops::GeneratorState enum'>GeneratorState</a></td><td class='docblock-short'><span class="stab unstable">Experimental</span><p>The result of a generator resumption.</p>
|
||
</td></tr></table><h2 id='traits' class='section-header'><a href="#traits">Traits</a></h2>
|
||
<table><tr class='module-item'><td><a class="trait" href="trait.Add.html" title='nom::lib::std::ops::Add trait'>Add</a></td><td class='docblock-short'><p>The addition operator <code>+</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.AddAssign.html" title='nom::lib::std::ops::AddAssign trait'>AddAssign</a></td><td class='docblock-short'><p>The addition assignment operator <code>+=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.BitAnd.html" title='nom::lib::std::ops::BitAnd trait'>BitAnd</a></td><td class='docblock-short'><p>The bitwise AND operator <code>&</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.BitAndAssign.html" title='nom::lib::std::ops::BitAndAssign trait'>BitAndAssign</a></td><td class='docblock-short'><p>The bitwise AND assignment operator <code>&=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.BitOr.html" title='nom::lib::std::ops::BitOr trait'>BitOr</a></td><td class='docblock-short'><p>The bitwise OR operator <code>|</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.BitOrAssign.html" title='nom::lib::std::ops::BitOrAssign trait'>BitOrAssign</a></td><td class='docblock-short'><p>The bitwise OR assignment operator <code>|=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.BitXor.html" title='nom::lib::std::ops::BitXor trait'>BitXor</a></td><td class='docblock-short'><p>The bitwise XOR operator <code>^</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.BitXorAssign.html" title='nom::lib::std::ops::BitXorAssign trait'>BitXorAssign</a></td><td class='docblock-short'><p>The bitwise XOR assignment operator <code>^=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Deref.html" title='nom::lib::std::ops::Deref trait'>Deref</a></td><td class='docblock-short'><p>Used for immutable dereferencing operations, like <code>*v</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.DerefMut.html" title='nom::lib::std::ops::DerefMut trait'>DerefMut</a></td><td class='docblock-short'><p>Used for mutable dereferencing operations, like in <code>*v = 1;</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Div.html" title='nom::lib::std::ops::Div trait'>Div</a></td><td class='docblock-short'><p>The division operator <code>/</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.DivAssign.html" title='nom::lib::std::ops::DivAssign trait'>DivAssign</a></td><td class='docblock-short'><p>The division assignment operator <code>/=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Drop.html" title='nom::lib::std::ops::Drop trait'>Drop</a></td><td class='docblock-short'><p>Used to run some code when a value goes out of scope.
|
||
This is sometimes called a 'destructor'.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Fn.html" title='nom::lib::std::ops::Fn trait'>Fn</a></td><td class='docblock-short'><p>The version of the call operator that takes an immutable receiver.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.FnMut.html" title='nom::lib::std::ops::FnMut trait'>FnMut</a></td><td class='docblock-short'><p>The version of the call operator that takes a mutable receiver.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.FnOnce.html" title='nom::lib::std::ops::FnOnce trait'>FnOnce</a></td><td class='docblock-short'><p>The version of the call operator that takes a by-value receiver.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Index.html" title='nom::lib::std::ops::Index trait'>Index</a></td><td class='docblock-short'><p>Used for indexing operations (<code>container[index]</code>) in immutable contexts.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.IndexMut.html" title='nom::lib::std::ops::IndexMut trait'>IndexMut</a></td><td class='docblock-short'><p>Used for indexing operations (<code>container[index]</code>) in mutable contexts.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Mul.html" title='nom::lib::std::ops::Mul trait'>Mul</a></td><td class='docblock-short'><p>The multiplication operator <code>*</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.MulAssign.html" title='nom::lib::std::ops::MulAssign trait'>MulAssign</a></td><td class='docblock-short'><p>The multiplication assignment operator <code>*=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Neg.html" title='nom::lib::std::ops::Neg trait'>Neg</a></td><td class='docblock-short'><p>The unary negation operator <code>-</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Not.html" title='nom::lib::std::ops::Not trait'>Not</a></td><td class='docblock-short'><p>The unary logical negation operator <code>!</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.RangeBounds.html" title='nom::lib::std::ops::RangeBounds trait'>RangeBounds</a></td><td class='docblock-short'><p><code>RangeBounds</code> is implemented by Rust's built-in range types, produced
|
||
by range syntax like <code>..</code>, <code>a..</code>, <code>..b</code>, <code>..=c</code>, <code>d..e</code>, or <code>f..=g</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Rem.html" title='nom::lib::std::ops::Rem trait'>Rem</a></td><td class='docblock-short'><p>The remainder operator <code>%</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.RemAssign.html" title='nom::lib::std::ops::RemAssign trait'>RemAssign</a></td><td class='docblock-short'><p>The remainder assignment operator <code>%=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Shl.html" title='nom::lib::std::ops::Shl trait'>Shl</a></td><td class='docblock-short'><p>The left shift operator <code><<</code>. Note that because this trait is implemented
|
||
for all integer types with multiple right-hand-side types, Rust's type
|
||
checker has special handling for <code>_ << _</code>, setting the result type for
|
||
integer operations to the type of the left-hand-side operand. This means
|
||
that though <code>a << b</code> and <code>a.shl(b)</code> are one and the same from an evaluation
|
||
standpoint, they are different when it comes to type inference.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.ShlAssign.html" title='nom::lib::std::ops::ShlAssign trait'>ShlAssign</a></td><td class='docblock-short'><p>The left shift assignment operator <code><<=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Shr.html" title='nom::lib::std::ops::Shr trait'>Shr</a></td><td class='docblock-short'><p>The right shift operator <code>>></code>. Note that because this trait is implemented
|
||
for all integer types with multiple right-hand-side types, Rust's type
|
||
checker has special handling for <code>_ >> _</code>, setting the result type for
|
||
integer operations to the type of the left-hand-side operand. This means
|
||
that though <code>a >> b</code> and <code>a.shr(b)</code> are one and the same from an evaluation
|
||
standpoint, they are different when it comes to type inference.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.ShrAssign.html" title='nom::lib::std::ops::ShrAssign trait'>ShrAssign</a></td><td class='docblock-short'><p>The right shift assignment operator <code>>>=</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.Sub.html" title='nom::lib::std::ops::Sub trait'>Sub</a></td><td class='docblock-short'><p>The subtraction operator <code>-</code>.</p>
|
||
</td></tr><tr class='module-item'><td><a class="trait" href="trait.SubAssign.html" title='nom::lib::std::ops::SubAssign trait'>SubAssign</a></td><td class='docblock-short'><p>The subtraction assignment operator <code>-=</code>.</p>
|
||
</td></tr><tr class='unstable module-item'><td><a class="trait" href="trait.CoerceUnsized.html" title='nom::lib::std::ops::CoerceUnsized trait'>CoerceUnsized</a></td><td class='docblock-short'><span class="stab unstable">Experimental</span><p>Trait that indicates that this is a pointer or a wrapper for one,
|
||
where unsizing can be performed on the pointee.</p>
|
||
</td></tr><tr class='unstable module-item'><td><a class="trait" href="trait.DispatchFromDyn.html" title='nom::lib::std::ops::DispatchFromDyn trait'>DispatchFromDyn</a></td><td class='docblock-short'><span class="stab unstable">Experimental</span><p>This is used for object safety, to check that a method's receiver type can be dispatched on.</p>
|
||
</td></tr><tr class='unstable module-item'><td><a class="trait" href="trait.Generator.html" title='nom::lib::std::ops::Generator trait'>Generator</a></td><td class='docblock-short'><span class="stab unstable">Experimental</span><p>The trait implemented by builtin generator types.</p>
|
||
</td></tr><tr class='unstable module-item'><td><a class="trait" href="trait.Try.html" title='nom::lib::std::ops::Try trait'>Try</a></td><td class='docblock-short'><span class="stab unstable">Experimental</span><p>A trait for customizing the behavior of the <code>?</code> operator.</p>
|
||
</td></tr></table></section><section id="search" class="content hidden"></section><section class="footer"></section><script>window.rootPath = "../../../../";window.currentCrate = "nom";</script><script src="../../../../aliases.js"></script><script src="../../../../main.js"></script><script defer src="../../../../search-index.js"></script></body></html> |