<!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 `i16` primitive in crate `std`.">
<meta name="keywords" content="rust, rustlang, rust-lang, i16">
<title>i16 - Rust</title>
<link rel="stylesheet" type="text/css" href="../normalize.css">
<link rel="stylesheet" type="text/css" href="../rustdoc.css">
<link rel="stylesheet" type="text/css" href="../main.css">
<link rel="shortcut icon" href="https://doc.rust-lang.org/favicon.ico">
</head>
<body class="rustdoc primitive">
<!--[if lte IE 8]>
<div class="warning">
This old browser is unsupported and will most likely display funky
things.
</div>
<![endif]-->
<nav class="sidebar">
<a href='../std/index.html'><img src='https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png' alt='logo' width='100'></a>
<p class='location'>Primitive Type i16</p><div class="block items"><ul><li><a href="#methods">Methods</a></li><li><a href="#implementations">Trait Implementations</a></li></ul></div><p class='location'><a href='index.html'>std</a></p><script>window.sidebarCurrent = {name: 'i16', ty: 'primitive', relpath: ''};</script><script defer src="sidebar-items.js"></script>
</nav>
<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">
</div>
</form>
</nav>
<section id='main' class="content">
<h1 class='fqn'><span class='in-band'>Primitive Type <a class="primitive" href=''>i16</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></span></h1>
<div class='docblock'><p>The 16-bit signed integer type.</p>
<p><em><a href="i16/index.html">See also the <code>std::i16</code> module</a>.</em></p>
<p>However, please note that examples are shared between primitive integer
types. So it's normal if you see usage of types like <code>i32</code> in there.</p>
</div><h2 id='methods'>Methods</h2><h3 class='impl'><span class='in-band'><code>impl <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#1203-1208' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.min_value' class="method"><span id='min_value.v' class='invisible'><code>const fn <a href='#method.min_value' class='fnname'>min_value</a>() -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Returns the smallest value that can be represented by this integer type.</p>
<h1 id='examples' class='section-header'><a href='#examples'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i8</span>::<span class="ident">min_value</span>(), <span class="op">-</span><span class="number">128</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(i8%3A%3Amin_value()%2C%20-128)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.max_value' class="method"><span id='max_value.v' class='invisible'><code>const fn <a href='#method.max_value' class='fnname'>max_value</a>() -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Returns the largest value that can be represented by this integer type.</p>
<h1 id='examples-1' class='section-header'><a href='#examples-1'>Examples</a></h1>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i8</span>::<span class="ident">max_value</span>(), <span class="number">127</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(i8%3A%3Amax_value()%2C%20127)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.from_str_radix' class="method"><span id='from_str_radix.v' class='invisible'><code>fn <a href='#method.from_str_radix' class='fnname'>from_str_radix</a>(src: &<a class="primitive" href="primitive.str.html">str</a>, radix: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.ParseIntError.html" title="struct std::num::ParseIntError">ParseIntError</a>></code></span></h4>
<div class='docblock'><p>Converts a string slice in a given base to an integer.</p>
<p>Leading and trailing whitespace represent an error.</p>
<h1 id='examples-2' class='section-header'><a href='#examples-2'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">from_str_radix</span>(<span class="string">"A"</span>, <span class="number">16</span>), <span class="prelude-val">Ok</span>(<span class="number">10</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(i32%3A%3Afrom_str_radix(%22A%22%2C%2016)%2C%20Ok(10))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.count_ones' class="method"><span id='count_ones.v' class='invisible'><code>fn <a href='#method.count_ones' class='fnname'>count_ones</a>(self) -> <a class="primitive" href="primitive.u32.html">u32</a></code></span></h4>
<div class='docblock'><p>Returns the number of ones in the binary representation of <code>self</code>.</p>
<h1 id='examples-3' class='section-header'><a href='#examples-3'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="op">-</span><span class="number">0b1000_0000i8</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">count_ones</span>(), <span class="number">1</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%20-0b1000_0000i8%3B%0A%0Aassert_eq!(n.count_ones()%2C%201)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.count_zeros' class="method"><span id='count_zeros.v' class='invisible'><code>fn <a href='#method.count_zeros' class='fnname'>count_zeros</a>(self) -> <a class="primitive" href="primitive.u32.html">u32</a></code></span></h4>
<div class='docblock'><p>Returns the number of zeros in the binary representation of <code>self</code>.</p>
<h1 id='examples-4' class='section-header'><a href='#examples-4'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="op">-</span><span class="number">0b1000_0000i8</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">count_zeros</span>(), <span class="number">7</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%20-0b1000_0000i8%3B%0A%0Aassert_eq!(n.count_zeros()%2C%207)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.leading_zeros' class="method"><span id='leading_zeros.v' class='invisible'><code>fn <a href='#method.leading_zeros' class='fnname'>leading_zeros</a>(self) -> <a class="primitive" href="primitive.u32.html">u32</a></code></span></h4>
<div class='docblock'><p>Returns the number of leading zeros in the binary representation
of <code>self</code>.</p>
<h1 id='examples-5' class='section-header'><a href='#examples-5'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="op">-</span><span class="number">1i16</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">leading_zeros</span>(), <span class="number">0</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%20-1i16%3B%0A%0Aassert_eq!(n.leading_zeros()%2C%200)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.trailing_zeros' class="method"><span id='trailing_zeros.v' class='invisible'><code>fn <a href='#method.trailing_zeros' class='fnname'>trailing_zeros</a>(self) -> <a class="primitive" href="primitive.u32.html">u32</a></code></span></h4>
<div class='docblock'><p>Returns the number of trailing zeros in the binary representation
of <code>self</code>.</p>
<h1 id='examples-6' class='section-header'><a href='#examples-6'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="op">-</span><span class="number">4i8</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">trailing_zeros</span>(), <span class="number">2</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%20-4i8%3B%0A%0Aassert_eq!(n.trailing_zeros()%2C%202)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.rotate_left' class="method"><span id='rotate_left.v' class='invisible'><code>fn <a href='#method.rotate_left' class='fnname'>rotate_left</a>(self, n: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Shifts the bits to the left by a specified amount, <code>n</code>,
wrapping the truncated bits to the end of the resulting integer.</p>
<p>Please note this isn't the same operation as <code><<</code>!</p>
<h1 id='examples-7' class='section-header'><a href='#examples-7'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="number">0x0123456789ABCDEFi64</span>;
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="op">-</span><span class="number">0x76543210FEDCBA99i64</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">rotate_left</span>(<span class="number">32</span>), <span class="ident">m</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%200x0123456789ABCDEFi64%3B%0Alet%20m%20%3D%20-0x76543210FEDCBA99i64%3B%0A%0Aassert_eq!(n.rotate_left(32)%2C%20m)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.rotate_right' class="method"><span id='rotate_right.v' class='invisible'><code>fn <a href='#method.rotate_right' class='fnname'>rotate_right</a>(self, n: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Shifts the bits to the right by a specified amount, <code>n</code>,
wrapping the truncated bits to the beginning of the resulting
integer.</p>
<p>Please note this isn't the same operation as <code>>></code>!</p>
<h1 id='examples-8' class='section-header'><a href='#examples-8'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="number">0x0123456789ABCDEFi64</span>;
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="op">-</span><span class="number">0xFEDCBA987654322i64</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">rotate_right</span>(<span class="number">4</span>), <span class="ident">m</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%200x0123456789ABCDEFi64%3B%0Alet%20m%20%3D%20-0xFEDCBA987654322i64%3B%0A%0Aassert_eq!(n.rotate_right(4)%2C%20m)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.swap_bytes' class="method"><span id='swap_bytes.v' class='invisible'><code>fn <a href='#method.swap_bytes' class='fnname'>swap_bytes</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Reverses the byte order of the integer.</p>
<h1 id='examples-9' class='section-header'><a href='#examples-9'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="number">0x0123456789ABCDEFi64</span>;
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="op">-</span><span class="number">0x1032547698BADCFFi64</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">swap_bytes</span>(), <span class="ident">m</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%20%200x0123456789ABCDEFi64%3B%0Alet%20m%20%3D%20-0x1032547698BADCFFi64%3B%0A%0Aassert_eq!(n.swap_bytes()%2C%20m)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.from_be' class="method"><span id='from_be.v' class='invisible'><code>fn <a href='#method.from_be' class='fnname'>from_be</a>(x: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Converts an integer from big endian to the target's endianness.</p>
<p>On big endian this is a no-op. On little endian the bytes are
swapped.</p>
<h1 id='examples-10' class='section-header'><a href='#examples-10'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="number">0x0123456789ABCDEFi64</span>;
<span class="kw">if</span> <span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_endian</span> <span class="op">=</span> <span class="string">"big"</span>) {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i64</span>::<span class="ident">from_be</span>(<span class="ident">n</span>), <span class="ident">n</span>)
} <span class="kw">else</span> {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i64</span>::<span class="ident">from_be</span>(<span class="ident">n</span>), <span class="ident">n</span>.<span class="ident">swap_bytes</span>())
}<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%200x0123456789ABCDEFi64%3B%0A%0Aif%20cfg!(target_endian%20%3D%20%22big%22)%20%7B%0A%20%20%20%20assert_eq!(i64%3A%3Afrom_be(n)%2C%20n)%0A%7D%20else%20%7B%0A%20%20%20%20assert_eq!(i64%3A%3Afrom_be(n)%2C%20n.swap_bytes())%0A%7D%0A%7D">Run</a></pre>
</div><h4 id='method.from_le' class="method"><span id='from_le.v' class='invisible'><code>fn <a href='#method.from_le' class='fnname'>from_le</a>(x: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Converts an integer from little endian to the target's endianness.</p>
<p>On little endian this is a no-op. On big endian the bytes are
swapped.</p>
<h1 id='examples-11' class='section-header'><a href='#examples-11'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="number">0x0123456789ABCDEFi64</span>;
<span class="kw">if</span> <span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_endian</span> <span class="op">=</span> <span class="string">"little"</span>) {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i64</span>::<span class="ident">from_le</span>(<span class="ident">n</span>), <span class="ident">n</span>)
} <span class="kw">else</span> {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i64</span>::<span class="ident">from_le</span>(<span class="ident">n</span>), <span class="ident">n</span>.<span class="ident">swap_bytes</span>())
}<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%200x0123456789ABCDEFi64%3B%0A%0Aif%20cfg!(target_endian%20%3D%20%22little%22)%20%7B%0A%20%20%20%20assert_eq!(i64%3A%3Afrom_le(n)%2C%20n)%0A%7D%20else%20%7B%0A%20%20%20%20assert_eq!(i64%3A%3Afrom_le(n)%2C%20n.swap_bytes())%0A%7D%0A%7D">Run</a></pre>
</div><h4 id='method.to_be' class="method"><span id='to_be.v' class='invisible'><code>fn <a href='#method.to_be' class='fnname'>to_be</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Converts <code>self</code> to big endian from the target's endianness.</p>
<p>On big endian this is a no-op. On little endian the bytes are
swapped.</p>
<h1 id='examples-12' class='section-header'><a href='#examples-12'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="number">0x0123456789ABCDEFi64</span>;
<span class="kw">if</span> <span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_endian</span> <span class="op">=</span> <span class="string">"big"</span>) {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">to_be</span>(), <span class="ident">n</span>)
} <span class="kw">else</span> {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">to_be</span>(), <span class="ident">n</span>.<span class="ident">swap_bytes</span>())
}<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%200x0123456789ABCDEFi64%3B%0A%0Aif%20cfg!(target_endian%20%3D%20%22big%22)%20%7B%0A%20%20%20%20assert_eq!(n.to_be()%2C%20n)%0A%7D%20else%20%7B%0A%20%20%20%20assert_eq!(n.to_be()%2C%20n.swap_bytes())%0A%7D%0A%7D">Run</a></pre>
</div><h4 id='method.to_le' class="method"><span id='to_le.v' class='invisible'><code>fn <a href='#method.to_le' class='fnname'>to_le</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Converts <code>self</code> to little endian from the target's endianness.</p>
<p>On little endian this is a no-op. On big endian the bytes are
swapped.</p>
<h1 id='examples-13' class='section-header'><a href='#examples-13'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">n</span> <span class="op">=</span> <span class="number">0x0123456789ABCDEFi64</span>;
<span class="kw">if</span> <span class="macro">cfg</span><span class="macro">!</span>(<span class="ident">target_endian</span> <span class="op">=</span> <span class="string">"little"</span>) {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">to_le</span>(), <span class="ident">n</span>)
} <span class="kw">else</span> {
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>.<span class="ident">to_le</span>(), <span class="ident">n</span>.<span class="ident">swap_bytes</span>())
}<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20n%20%3D%200x0123456789ABCDEFi64%3B%0A%0Aif%20cfg!(target_endian%20%3D%20%22little%22)%20%7B%0A%20%20%20%20assert_eq!(n.to_le()%2C%20n)%0A%7D%20else%20%7B%0A%20%20%20%20assert_eq!(n.to_le()%2C%20n.swap_bytes())%0A%7D%0A%7D">Run</a></pre>
</div><h4 id='method.checked_add' class="method"><span id='checked_add.v' class='invisible'><code>fn <a href='#method.checked_add' class='fnname'>checked_add</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code></span></h4>
<div class='docblock'><p>Checked integer addition. Computes <code>self + other</code>, returning <code>None</code>
if overflow occurred.</p>
<h1 id='examples-14' class='section-header'><a href='#examples-14'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">7i16</span>.<span class="ident">checked_add</span>(<span class="number">32760</span>), <span class="prelude-val">Some</span>(<span class="number">32767</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">8i16</span>.<span class="ident">checked_add</span>(<span class="number">32760</span>), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(7i16.checked_add(32760)%2C%20Some(32767))%3B%0Aassert_eq!(8i16.checked_add(32760)%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.checked_sub' class="method"><span id='checked_sub.v' class='invisible'><code>fn <a href='#method.checked_sub' class='fnname'>checked_sub</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code></span></h4>
<div class='docblock'><p>Checked integer subtraction. Computes <code>self - other</code>, returning
<code>None</code> if underflow occurred.</p>
<h1 id='examples-15' class='section-header'><a href='#examples-15'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">127i8</span>).<span class="ident">checked_sub</span>(<span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="op">-</span><span class="number">128</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">checked_sub</span>(<span class="number">1</span>), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!((-127i8).checked_sub(1)%2C%20Some(-128))%3B%0Aassert_eq!((-128i8).checked_sub(1)%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.checked_mul' class="method"><span id='checked_mul.v' class='invisible'><code>fn <a href='#method.checked_mul' class='fnname'>checked_mul</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code></span></h4>
<div class='docblock'><p>Checked integer multiplication. Computes <code>self * other</code>, returning
<code>None</code> if underflow or overflow occurred.</p>
<h1 id='examples-16' class='section-header'><a href='#examples-16'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">6i8</span>.<span class="ident">checked_mul</span>(<span class="number">21</span>), <span class="prelude-val">Some</span>(<span class="number">126</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">6i8</span>.<span class="ident">checked_mul</span>(<span class="number">22</span>), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(6i8.checked_mul(21)%2C%20Some(126))%3B%0Aassert_eq!(6i8.checked_mul(22)%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.checked_div' class="method"><span id='checked_div.v' class='invisible'><code>fn <a href='#method.checked_div' class='fnname'>checked_div</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code></span></h4>
<div class='docblock'><p>Checked integer division. Computes <code>self / other</code>, returning <code>None</code>
if <code>other == 0</code> or the operation results in underflow or overflow.</p>
<h1 id='examples-17' class='section-header'><a href='#examples-17'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">127i8</span>).<span class="ident">checked_div</span>(<span class="op">-</span><span class="number">1</span>), <span class="prelude-val">Some</span>(<span class="number">127</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">checked_div</span>(<span class="op">-</span><span class="number">1</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="number">1i8</span>).<span class="ident">checked_div</span>(<span class="number">0</span>), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!((-127i8).checked_div(-1)%2C%20Some(127))%3B%0Aassert_eq!((-128i8).checked_div(-1)%2C%20None)%3B%0Aassert_eq!((1i8).checked_div(0)%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.checked_rem' class="method"><span id='checked_rem.v' class='invisible'><code>fn <a href='#method.checked_rem' class='fnname'>checked_rem</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Checked integer remainder. Computes <code>self % other</code>, returning <code>None</code>
if <code>other == 0</code> or the operation results in underflow or overflow.</p>
<h1 id='examples-18' class='section-header'><a href='#examples-18'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5i32</span>.<span class="ident">checked_rem</span>(<span class="number">2</span>), <span class="prelude-val">Some</span>(<span class="number">1</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5i32</span>.<span class="ident">checked_rem</span>(<span class="number">0</span>), <span class="prelude-val">None</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">MIN</span>.<span class="ident">checked_rem</span>(<span class="op">-</span><span class="number">1</span>), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!(5i32.checked_rem(2)%2C%20Some(1))%3B%0Aassert_eq!(5i32.checked_rem(0)%2C%20None)%3B%0Aassert_eq!(i32%3A%3AMIN.checked_rem(-1)%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.checked_neg' class="method"><span id='checked_neg.v' class='invisible'><code>fn <a href='#method.checked_neg' class='fnname'>checked_neg</a>(self) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Checked negation. Computes <code>-self</code>, returning <code>None</code> if <code>self == MIN</code>.</p>
<h1 id='examples-19' class='section-header'><a href='#examples-19'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5i32</span>.<span class="ident">checked_neg</span>(), <span class="prelude-val">Some</span>(<span class="op">-</span><span class="number">5</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">MIN</span>.<span class="ident">checked_neg</span>(), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!(5i32.checked_neg()%2C%20Some(-5))%3B%0Aassert_eq!(i32%3A%3AMIN.checked_neg()%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.checked_shl' class="method"><span id='checked_shl.v' class='invisible'><code>fn <a href='#method.checked_shl' class='fnname'>checked_shl</a>(self, rhs: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Checked shift left. Computes <code>self << rhs</code>, returning <code>None</code>
if <code>rhs</code> is larger than or equal to the number of bits in <code>self</code>.</p>
<h1 id='examples-20' class='section-header'><a href='#examples-20'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0x10i32</span>.<span class="ident">checked_shl</span>(<span class="number">4</span>), <span class="prelude-val">Some</span>(<span class="number">0x100</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0x10i32</span>.<span class="ident">checked_shl</span>(<span class="number">33</span>), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(0x10i32.checked_shl(4)%2C%20Some(0x100))%3B%0Aassert_eq!(0x10i32.checked_shl(33)%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.checked_shr' class="method"><span id='checked_shr.v' class='invisible'><code>fn <a href='#method.checked_shr' class='fnname'>checked_shr</a>(self, rhs: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Checked shift right. Computes <code>self >> rhs</code>, returning <code>None</code>
if <code>rhs</code> is larger than or equal to the number of bits in <code>self</code>.</p>
<h1 id='examples-21' class='section-header'><a href='#examples-21'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0x10i32</span>.<span class="ident">checked_shr</span>(<span class="number">4</span>), <span class="prelude-val">Some</span>(<span class="number">0x1</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0x10i32</span>.<span class="ident">checked_shr</span>(<span class="number">33</span>), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(0x10i32.checked_shr(4)%2C%20Some(0x1))%3B%0Aassert_eq!(0x10i32.checked_shr(33)%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.checked_abs' class="method"><span id='checked_abs.v' class='invisible'><code>fn <a href='#method.checked_abs' class='fnname'>checked_abs</a>(self) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code><div class='since' title='Stable since Rust version 1.13.0'>1.13.0</div></span></h4>
<div class='docblock'><p>Checked absolute value. Computes <code>self.abs()</code>, returning <code>None</code> if
<code>self == MIN</code>.</p>
<h1 id='examples-22' class='section-header'><a href='#examples-22'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">5i32</span>).<span class="ident">checked_abs</span>(), <span class="prelude-val">Some</span>(<span class="number">5</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">MIN</span>.<span class="ident">checked_abs</span>(), <span class="prelude-val">None</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!((-5i32).checked_abs()%2C%20Some(5))%3B%0Aassert_eq!(i32%3A%3AMIN.checked_abs()%2C%20None)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.saturating_add' class="method"><span id='saturating_add.v' class='invisible'><code>fn <a href='#method.saturating_add' class='fnname'>saturating_add</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Saturating integer addition. Computes <code>self + other</code>, saturating at
the numeric bounds instead of overflowing.</p>
<h1 id='examples-23' class='section-header'><a href='#examples-23'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i8</span>.<span class="ident">saturating_add</span>(<span class="number">1</span>), <span class="number">101</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i8</span>.<span class="ident">saturating_add</span>(<span class="number">127</span>), <span class="number">127</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(100i8.saturating_add(1)%2C%20101)%3B%0Aassert_eq!(100i8.saturating_add(127)%2C%20127)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.saturating_sub' class="method"><span id='saturating_sub.v' class='invisible'><code>fn <a href='#method.saturating_sub' class='fnname'>saturating_sub</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Saturating integer subtraction. Computes <code>self - other</code>, saturating
at the numeric bounds instead of overflowing.</p>
<h1 id='examples-24' class='section-header'><a href='#examples-24'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i8</span>.<span class="ident">saturating_sub</span>(<span class="number">127</span>), <span class="op">-</span><span class="number">27</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">100i8</span>).<span class="ident">saturating_sub</span>(<span class="number">127</span>), <span class="op">-</span><span class="number">128</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(100i8.saturating_sub(127)%2C%20-27)%3B%0Aassert_eq!((-100i8).saturating_sub(127)%2C%20-128)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.saturating_mul' class="method"><span id='saturating_mul.v' class='invisible'><code>fn <a href='#method.saturating_mul' class='fnname'>saturating_mul</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Saturating integer multiplication. Computes <code>self * other</code>,
saturating at the numeric bounds instead of overflowing.</p>
<h1 id='examples-25' class='section-header'><a href='#examples-25'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i32</span>.<span class="ident">saturating_mul</span>(<span class="number">127</span>), <span class="number">12700</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="number">1i32</span> <span class="op"><<</span> <span class="number">23</span>).<span class="ident">saturating_mul</span>(<span class="number">1</span> <span class="op"><<</span> <span class="number">23</span>), <span class="ident">i32</span>::<span class="ident">MAX</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">1i32</span> <span class="op"><<</span> <span class="number">23</span>).<span class="ident">saturating_mul</span>(<span class="number">1</span> <span class="op"><<</span> <span class="number">23</span>), <span class="ident">i32</span>::<span class="ident">MIN</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!(100i32.saturating_mul(127)%2C%2012700)%3B%0Aassert_eq!((1i32%20%3C%3C%2023).saturating_mul(1%20%3C%3C%2023)%2C%20i32%3A%3AMAX)%3B%0Aassert_eq!((-1i32%20%3C%3C%2023).saturating_mul(1%20%3C%3C%2023)%2C%20i32%3A%3AMIN)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_add' class="method"><span id='wrapping_add.v' class='invisible'><code>fn <a href='#method.wrapping_add' class='fnname'>wrapping_add</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Wrapping (modular) addition. Computes <code>self + other</code>,
wrapping around at the boundary of the type.</p>
<h1 id='examples-26' class='section-header'><a href='#examples-26'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i8</span>.<span class="ident">wrapping_add</span>(<span class="number">27</span>), <span class="number">127</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i8</span>.<span class="ident">wrapping_add</span>(<span class="number">127</span>), <span class="op">-</span><span class="number">29</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(100i8.wrapping_add(27)%2C%20127)%3B%0Aassert_eq!(100i8.wrapping_add(127)%2C%20-29)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_sub' class="method"><span id='wrapping_sub.v' class='invisible'><code>fn <a href='#method.wrapping_sub' class='fnname'>wrapping_sub</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Wrapping (modular) subtraction. Computes <code>self - other</code>,
wrapping around at the boundary of the type.</p>
<h1 id='examples-27' class='section-header'><a href='#examples-27'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0i8</span>.<span class="ident">wrapping_sub</span>(<span class="number">127</span>), <span class="op">-</span><span class="number">127</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">2i8</span>).<span class="ident">wrapping_sub</span>(<span class="number">127</span>), <span class="number">127</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(0i8.wrapping_sub(127)%2C%20-127)%3B%0Aassert_eq!((-2i8).wrapping_sub(127)%2C%20127)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_mul' class="method"><span id='wrapping_mul.v' class='invisible'><code>fn <a href='#method.wrapping_mul' class='fnname'>wrapping_mul</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Wrapping (modular) multiplication. Computes <code>self * other</code>, wrapping around at the boundary of the type.</p>
<h1 id='examples-28' class='section-header'><a href='#examples-28'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">10i8</span>.<span class="ident">wrapping_mul</span>(<span class="number">12</span>), <span class="number">120</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">11i8</span>.<span class="ident">wrapping_mul</span>(<span class="number">12</span>), <span class="op">-</span><span class="number">124</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(10i8.wrapping_mul(12)%2C%20120)%3B%0Aassert_eq!(11i8.wrapping_mul(12)%2C%20-124)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_div' class="method"><span id='wrapping_div.v' class='invisible'><code>fn <a href='#method.wrapping_div' class='fnname'>wrapping_div</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div></span></h4>
<div class='docblock'><p>Wrapping (modular) division. Computes <code>self / other</code>,
wrapping around at the boundary of the type.</p>
<p>The only case where such wrapping can occur is when one
divides <code>MIN / -1</code> on a signed type (where <code>MIN</code> is the
negative minimal value for the type); this is equivalent
to <code>-MIN</code>, a positive value that is too large to represent
in the type. In such a case, this function returns <code>MIN</code>
itself.</p>
<h1 id='panics' class='section-header'><a href='#panics'>Panics</a></h1>
<p>This function will panic if <code>rhs</code> is 0.</p>
<h1 id='examples-29' class='section-header'><a href='#examples-29'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100u8</span>.<span class="ident">wrapping_div</span>(<span class="number">10</span>), <span class="number">10</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">wrapping_div</span>(<span class="op">-</span><span class="number">1</span>), <span class="op">-</span><span class="number">128</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(100u8.wrapping_div(10)%2C%2010)%3B%0Aassert_eq!((-128i8).wrapping_div(-1)%2C%20-128)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_rem' class="method"><span id='wrapping_rem.v' class='invisible'><code>fn <a href='#method.wrapping_rem' class='fnname'>wrapping_rem</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div></span></h4>
<div class='docblock'><p>Wrapping (modular) remainder. Computes <code>self % other</code>,
wrapping around at the boundary of the type.</p>
<p>Such wrap-around never actually occurs mathematically;
implementation artifacts make <code>x % y</code> invalid for <code>MIN / -1</code> on a signed type (where <code>MIN</code> is the negative
minimal value). In such a case, this function returns <code>0</code>.</p>
<h1 id='panics-1' class='section-header'><a href='#panics-1'>Panics</a></h1>
<p>This function will panic if <code>rhs</code> is 0.</p>
<h1 id='examples-30' class='section-header'><a href='#examples-30'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i8</span>.<span class="ident">wrapping_rem</span>(<span class="number">10</span>), <span class="number">0</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">wrapping_rem</span>(<span class="op">-</span><span class="number">1</span>), <span class="number">0</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(100i8.wrapping_rem(10)%2C%200)%3B%0Aassert_eq!((-128i8).wrapping_rem(-1)%2C%200)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_neg' class="method"><span id='wrapping_neg.v' class='invisible'><code>fn <a href='#method.wrapping_neg' class='fnname'>wrapping_neg</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div></span></h4>
<div class='docblock'><p>Wrapping (modular) negation. Computes <code>-self</code>,
wrapping around at the boundary of the type.</p>
<p>The only case where such wrapping can occur is when one
negates <code>MIN</code> on a signed type (where <code>MIN</code> is the
negative minimal value for the type); this is a positive
value that is too large to represent in the type. In such
a case, this function returns <code>MIN</code> itself.</p>
<h1 id='examples-31' class='section-header'><a href='#examples-31'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i8</span>.<span class="ident">wrapping_neg</span>(), <span class="op">-</span><span class="number">100</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">wrapping_neg</span>(), <span class="op">-</span><span class="number">128</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(100i8.wrapping_neg()%2C%20-100)%3B%0Aassert_eq!((-128i8).wrapping_neg()%2C%20-128)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_shl' class="method"><span id='wrapping_shl.v' class='invisible'><code>fn <a href='#method.wrapping_shl' class='fnname'>wrapping_shl</a>(self, rhs: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div></span></h4>
<div class='docblock'><p>Panic-free bitwise shift-left; yields <code>self << mask(rhs)</code>,
where <code>mask</code> removes any high-order bits of <code>rhs</code> that
would cause the shift to exceed the bitwidth of the type.</p>
<p>Note that this is <em>not</em> the same as a rotate-left; the
RHS of a wrapping shift-left is restricted to the range
of the type, rather than the bits shifted out of the LHS
being returned to the other end. The primitive integer
types all implement a <code>rotate_left</code> function, which may
be what you want instead.</p>
<h1 id='examples-32' class='section-header'><a href='#examples-32'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">1i8</span>).<span class="ident">wrapping_shl</span>(<span class="number">7</span>), <span class="op">-</span><span class="number">128</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">1i8</span>).<span class="ident">wrapping_shl</span>(<span class="number">8</span>), <span class="op">-</span><span class="number">1</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!((-1i8).wrapping_shl(7)%2C%20-128)%3B%0Aassert_eq!((-1i8).wrapping_shl(8)%2C%20-1)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_shr' class="method"><span id='wrapping_shr.v' class='invisible'><code>fn <a href='#method.wrapping_shr' class='fnname'>wrapping_shr</a>(self, rhs: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div></span></h4>
<div class='docblock'><p>Panic-free bitwise shift-right; yields <code>self >> mask(rhs)</code>,
where <code>mask</code> removes any high-order bits of <code>rhs</code> that
would cause the shift to exceed the bitwidth of the type.</p>
<p>Note that this is <em>not</em> the same as a rotate-right; the
RHS of a wrapping shift-right is restricted to the range
of the type, rather than the bits shifted out of the LHS
being returned to the other end. The primitive integer
types all implement a <code>rotate_right</code> function, which may
be what you want instead.</p>
<h1 id='examples-33' class='section-header'><a href='#examples-33'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">wrapping_shr</span>(<span class="number">7</span>), <span class="op">-</span><span class="number">1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">wrapping_shr</span>(<span class="number">8</span>), <span class="op">-</span><span class="number">128</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!((-128i8).wrapping_shr(7)%2C%20-1)%3B%0Aassert_eq!((-128i8).wrapping_shr(8)%2C%20-128)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.wrapping_abs' class="method"><span id='wrapping_abs.v' class='invisible'><code>fn <a href='#method.wrapping_abs' class='fnname'>wrapping_abs</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code><div class='since' title='Stable since Rust version 1.13.0'>1.13.0</div></span></h4>
<div class='docblock'><p>Wrapping (modular) absolute value. Computes <code>self.abs()</code>,
wrapping around at the boundary of the type.</p>
<p>The only case where such wrapping can occur is when one takes
the absolute value of the negative minimal value for the type
this is a positive value that is too large to represent in the
type. In such a case, this function returns <code>MIN</code> itself.</p>
<h1 id='examples-34' class='section-header'><a href='#examples-34'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">100i8</span>.<span class="ident">wrapping_abs</span>(), <span class="number">100</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">100i8</span>).<span class="ident">wrapping_abs</span>(), <span class="number">100</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">wrapping_abs</span>(), <span class="op">-</span><span class="number">128</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">wrapping_abs</span>() <span class="kw">as</span> <span class="ident">u8</span>, <span class="number">128</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(100i8.wrapping_abs()%2C%20100)%3B%0Aassert_eq!((-100i8).wrapping_abs()%2C%20100)%3B%0Aassert_eq!((-128i8).wrapping_abs()%2C%20-128)%3B%0Aassert_eq!((-128i8).wrapping_abs()%20as%20u8%2C%20128)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_add' class="method"><span id='overflowing_add.v' class='invisible'><code>fn <a href='#method.overflowing_add' class='fnname'>overflowing_add</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Calculates <code>self</code> + <code>rhs</code></p>
<p>Returns a tuple of the addition along with a boolean indicating
whether an arithmetic overflow would occur. If an overflow would
have occurred then the wrapped value is returned.</p>
<h1 id='examples-35' class='section-header'><a href='#examples-35'>Examples</a></h1>
<p>Basic usage</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5i32</span>.<span class="ident">overflowing_add</span>(<span class="number">2</span>), (<span class="number">7</span>, <span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">MAX</span>.<span class="ident">overflowing_add</span>(<span class="number">1</span>), (<span class="ident">i32</span>::<span class="ident">MIN</span>, <span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!(5i32.overflowing_add(2)%2C%20(7%2C%20false))%3B%0Aassert_eq!(i32%3A%3AMAX.overflowing_add(1)%2C%20(i32%3A%3AMIN%2C%20true))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_sub' class="method"><span id='overflowing_sub.v' class='invisible'><code>fn <a href='#method.overflowing_sub' class='fnname'>overflowing_sub</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Calculates <code>self</code> - <code>rhs</code></p>
<p>Returns a tuple of the subtraction along with a boolean indicating
whether an arithmetic overflow would occur. If an overflow would
have occurred then the wrapped value is returned.</p>
<h1 id='examples-36' class='section-header'><a href='#examples-36'>Examples</a></h1>
<p>Basic usage</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5i32</span>.<span class="ident">overflowing_sub</span>(<span class="number">2</span>), (<span class="number">3</span>, <span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">MIN</span>.<span class="ident">overflowing_sub</span>(<span class="number">1</span>), (<span class="ident">i32</span>::<span class="ident">MAX</span>, <span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!(5i32.overflowing_sub(2)%2C%20(3%2C%20false))%3B%0Aassert_eq!(i32%3A%3AMIN.overflowing_sub(1)%2C%20(i32%3A%3AMAX%2C%20true))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_mul' class="method"><span id='overflowing_mul.v' class='invisible'><code>fn <a href='#method.overflowing_mul' class='fnname'>overflowing_mul</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Calculates the multiplication of <code>self</code> and <code>rhs</code>.</p>
<p>Returns a tuple of the multiplication along with a boolean
indicating whether an arithmetic overflow would occur. If an
overflow would have occurred then the wrapped value is returned.</p>
<h1 id='examples-37' class='section-header'><a href='#examples-37'>Examples</a></h1>
<p>Basic usage</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5i32</span>.<span class="ident">overflowing_mul</span>(<span class="number">2</span>), (<span class="number">10</span>, <span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">1_000_000_000i32</span>.<span class="ident">overflowing_mul</span>(<span class="number">10</span>), (<span class="number">1410065408</span>, <span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(5i32.overflowing_mul(2)%2C%20(10%2C%20false))%3B%0Aassert_eq!(1_000_000_000i32.overflowing_mul(10)%2C%20(1410065408%2C%20true))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_div' class="method"><span id='overflowing_div.v' class='invisible'><code>fn <a href='#method.overflowing_div' class='fnname'>overflowing_div</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Calculates the divisor when <code>self</code> is divided by <code>rhs</code>.</p>
<p>Returns a tuple of the divisor along with a boolean indicating
whether an arithmetic overflow would occur. If an overflow would
occur then self is returned.</p>
<h1 id='panics-2' class='section-header'><a href='#panics-2'>Panics</a></h1>
<p>This function will panic if <code>rhs</code> is 0.</p>
<h1 id='examples-38' class='section-header'><a href='#examples-38'>Examples</a></h1>
<p>Basic usage</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5i32</span>.<span class="ident">overflowing_div</span>(<span class="number">2</span>), (<span class="number">2</span>, <span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">MIN</span>.<span class="ident">overflowing_div</span>(<span class="op">-</span><span class="number">1</span>), (<span class="ident">i32</span>::<span class="ident">MIN</span>, <span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!(5i32.overflowing_div(2)%2C%20(2%2C%20false))%3B%0Aassert_eq!(i32%3A%3AMIN.overflowing_div(-1)%2C%20(i32%3A%3AMIN%2C%20true))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_rem' class="method"><span id='overflowing_rem.v' class='invisible'><code>fn <a href='#method.overflowing_rem' class='fnname'>overflowing_rem</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Calculates the remainder when <code>self</code> is divided by <code>rhs</code>.</p>
<p>Returns a tuple of the remainder after dividing along with a boolean
indicating whether an arithmetic overflow would occur. If an
overflow would occur then 0 is returned.</p>
<h1 id='panics-3' class='section-header'><a href='#panics-3'>Panics</a></h1>
<p>This function will panic if <code>rhs</code> is 0.</p>
<h1 id='examples-39' class='section-header'><a href='#examples-39'>Examples</a></h1>
<p>Basic usage</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">5i32</span>.<span class="ident">overflowing_rem</span>(<span class="number">2</span>), (<span class="number">1</span>, <span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">MIN</span>.<span class="ident">overflowing_rem</span>(<span class="op">-</span><span class="number">1</span>), (<span class="number">0</span>, <span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!(5i32.overflowing_rem(2)%2C%20(1%2C%20false))%3B%0Aassert_eq!(i32%3A%3AMIN.overflowing_rem(-1)%2C%20(0%2C%20true))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_neg' class="method"><span id='overflowing_neg.v' class='invisible'><code>fn <a href='#method.overflowing_neg' class='fnname'>overflowing_neg</a>(self) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Negates self, overflowing if this is equal to the minimum value.</p>
<p>Returns a tuple of the negated version of self along with a boolean
indicating whether an overflow happened. If <code>self</code> is the minimum
value (e.g. <code>i32::MIN</code> for values of type <code>i32</code>), then the minimum
value will be returned again and <code>true</code> will be returned for an
overflow happening.</p>
<h1 id='examples-40' class='section-header'><a href='#examples-40'>Examples</a></h1>
<p>Basic usage</p>
<pre class="rust rust-example-rendered">
<span class="kw">use</span> <span class="ident">std</span>::<span class="ident">i32</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">2i32</span>.<span class="ident">overflowing_neg</span>(), (<span class="op">-</span><span class="number">2</span>, <span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">i32</span>::<span class="ident">MIN</span>.<span class="ident">overflowing_neg</span>(), (<span class="ident">i32</span>::<span class="ident">MIN</span>, <span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Ause%20std%3A%3Ai32%3B%0A%0Aassert_eq!(2i32.overflowing_neg()%2C%20(-2%2C%20false))%3B%0Aassert_eq!(i32%3A%3AMIN.overflowing_neg()%2C%20(i32%3A%3AMIN%2C%20true))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_shl' class="method"><span id='overflowing_shl.v' class='invisible'><code>fn <a href='#method.overflowing_shl' class='fnname'>overflowing_shl</a>(self, rhs: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Shifts self left by <code>rhs</code> bits.</p>
<p>Returns a tuple of the shifted version of self along with a boolean
indicating whether the shift value was larger than or equal to the
number of bits. If the shift value is too large, then value is
masked (N-1) where N is the number of bits, and this value is then
used to perform the shift.</p>
<h1 id='examples-41' class='section-header'><a href='#examples-41'>Examples</a></h1>
<p>Basic usage</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0x10i32</span>.<span class="ident">overflowing_shl</span>(<span class="number">4</span>), (<span class="number">0x100</span>, <span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0x10i32</span>.<span class="ident">overflowing_shl</span>(<span class="number">36</span>), (<span class="number">0x100</span>, <span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(0x10i32.overflowing_shl(4)%2C%20(0x100%2C%20false))%3B%0Aassert_eq!(0x10i32.overflowing_shl(36)%2C%20(0x100%2C%20true))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_shr' class="method"><span id='overflowing_shr.v' class='invisible'><code>fn <a href='#method.overflowing_shr' class='fnname'>overflowing_shr</a>(self, rhs: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div></span></h4>
<div class='docblock'><p>Shifts self right by <code>rhs</code> bits.</p>
<p>Returns a tuple of the shifted version of self along with a boolean
indicating whether the shift value was larger than or equal to the
number of bits. If the shift value is too large, then value is
masked (N-1) where N is the number of bits, and this value is then
used to perform the shift.</p>
<h1 id='examples-42' class='section-header'><a href='#examples-42'>Examples</a></h1>
<p>Basic usage</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0x10i32</span>.<span class="ident">overflowing_shr</span>(<span class="number">4</span>), (<span class="number">0x1</span>, <span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0x10i32</span>.<span class="ident">overflowing_shr</span>(<span class="number">36</span>), (<span class="number">0x1</span>, <span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(0x10i32.overflowing_shr(4)%2C%20(0x1%2C%20false))%3B%0Aassert_eq!(0x10i32.overflowing_shr(36)%2C%20(0x1%2C%20true))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.overflowing_abs' class="method"><span id='overflowing_abs.v' class='invisible'><code>fn <a href='#method.overflowing_abs' class='fnname'>overflowing_abs</a>(self) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i16.html">i16</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code><div class='since' title='Stable since Rust version 1.13.0'>1.13.0</div></span></h4>
<div class='docblock'><p>Computes the absolute value of <code>self</code>.</p>
<p>Returns a tuple of the absolute version of self along with a
boolean indicating whether an overflow happened. If self is the
minimum value (e.g. i32::MIN for values of type i32), then the
minimum value will be returned again and true will be returned for
an overflow happening.</p>
<h1 id='examples-43' class='section-header'><a href='#examples-43'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">10i8</span>.<span class="ident">overflowing_abs</span>(), (<span class="number">10</span>,<span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">10i8</span>).<span class="ident">overflowing_abs</span>(), (<span class="number">10</span>,<span class="bool-val">false</span>));
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">128i8</span>).<span class="ident">overflowing_abs</span>(), (<span class="op">-</span><span class="number">128</span>,<span class="bool-val">true</span>));<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(10i8.overflowing_abs()%2C%20(10%2Cfalse))%3B%0Aassert_eq!((-10i8).overflowing_abs()%2C%20(10%2Cfalse))%3B%0Aassert_eq!((-128i8).overflowing_abs()%2C%20(-128%2Ctrue))%3B%0A%7D">Run</a></pre>
</div><h4 id='method.pow' class="method"><span id='pow.v' class='invisible'><code>fn <a href='#method.pow' class='fnname'>pow</a>(self, exp: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Raises self to the power of <code>exp</code>, using exponentiation by squaring.</p>
<h1 id='examples-44' class='section-header'><a href='#examples-44'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="kw">let</span> <span class="ident">x</span>: <span class="ident">i32</span> <span class="op">=</span> <span class="number">2</span>; <span class="comment">// or any other integer type</span>
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">x</span>.<span class="ident">pow</span>(<span class="number">4</span>), <span class="number">16</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Alet%20x%3A%20i32%20%3D%202%3B%20%2F%2F%20or%20any%20other%20integer%20type%0A%0Aassert_eq!(x.pow(4)%2C%2016)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.abs' class="method"><span id='abs.v' class='invisible'><code>fn <a href='#method.abs' class='fnname'>abs</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Computes the absolute value of <code>self</code>.</p>
<h1 id='overflow-behavior' class='section-header'><a href='#overflow-behavior'>Overflow behavior</a></h1>
<p>The absolute value of <code>i32::min_value()</code> cannot be represented as an
<code>i32</code>, and attempting to calculate it will cause an overflow. This
means that code in debug mode will trigger a panic on this case and
optimized code will return <code>i32::min_value()</code> without a panic.</p>
<h1 id='examples-45' class='section-header'><a href='#examples-45'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">10i8</span>.<span class="ident">abs</span>(), <span class="number">10</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">10i8</span>).<span class="ident">abs</span>(), <span class="number">10</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(10i8.abs()%2C%2010)%3B%0Aassert_eq!((-10i8).abs()%2C%2010)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.signum' class="method"><span id='signum.v' class='invisible'><code>fn <a href='#method.signum' class='fnname'>signum</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Returns a number representing sign of <code>self</code>.</p>
<ul>
<li><code>0</code> if the number is zero</li>
<li><code>1</code> if the number is positive</li>
<li><code>-1</code> if the number is negative</li>
</ul>
<h1 id='examples-46' class='section-header'><a href='#examples-46'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">10i8</span>.<span class="ident">signum</span>(), <span class="number">1</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="number">0i8</span>.<span class="ident">signum</span>(), <span class="number">0</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>((<span class="op">-</span><span class="number">10i8</span>).<span class="ident">signum</span>(), <span class="op">-</span><span class="number">1</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert_eq!(10i8.signum()%2C%201)%3B%0Aassert_eq!(0i8.signum()%2C%200)%3B%0Aassert_eq!((-10i8).signum()%2C%20-1)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.is_positive' class="method"><span id='is_positive.v' class='invisible'><code>fn <a href='#method.is_positive' class='fnname'>is_positive</a>(self) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='docblock'><p>Returns <code>true</code> if <code>self</code> is positive and <code>false</code> if the number
is zero or negative.</p>
<h1 id='examples-47' class='section-header'><a href='#examples-47'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert</span><span class="macro">!</span>(<span class="number">10i8</span>.<span class="ident">is_positive</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span>(<span class="op">-</span><span class="number">10i8</span>).<span class="ident">is_positive</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert!(10i8.is_positive())%3B%0Aassert!(!(-10i8).is_positive())%3B%0A%7D">Run</a></pre>
</div><h4 id='method.is_negative' class="method"><span id='is_negative.v' class='invisible'><code>fn <a href='#method.is_negative' class='fnname'>is_negative</a>(self) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='docblock'><p>Returns <code>true</code> if <code>self</code> is negative and <code>false</code> if the number
is zero or positive.</p>
<h1 id='examples-48' class='section-header'><a href='#examples-48'>Examples</a></h1>
<p>Basic usage:</p>
<pre class="rust rust-example-rendered">
<span class="macro">assert</span><span class="macro">!</span>((<span class="op">-</span><span class="number">10i8</span>).<span class="ident">is_negative</span>());
<span class="macro">assert</span><span class="macro">!</span>(<span class="op">!</span><span class="number">10i8</span>.<span class="ident">is_negative</span>());<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=fn%20main()%20%7B%0Aassert!((-10i8).is_negative())%3B%0Aassert!(!10i8.is_negative())%3B%0A%7D">Run</a></pre>
</div></div><h2 id='implementations'>Trait Implementations</h2><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output' class="type"><span id='Output.t' class='invisible'><code>type <a href='../std/ops/trait.Sub.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>-</code> operator</p>
</div><h4 id='method.sub' class="method"><span id='sub.v' class='invisible'><code>fn <a href='../std/ops/trait.Sub.html#tymethod.sub' class='fnname'>sub</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>-</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#413-419' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-1' class="type"><span id='Output.t-1' class='invisible'><code>type <a href='../std/ops/trait.Sub.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>-</code> operator</p>
</div><h4 id='method.sub-1' class="method"><span id='sub.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Sub.html#tymethod.sub' class='fnname'>sub</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>-</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-2' class="type"><span id='Output.t-2' class='invisible'><code>type <a href='../std/ops/trait.Sub.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>-</code> operator</p>
</div><h4 id='method.sub-2' class="method"><span id='sub.v-2' class='invisible'><code>fn <a href='../std/ops/trait.Sub.html#tymethod.sub' class='fnname'>sub</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>-</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-3' class="type"><span id='Output.t-3' class='invisible'><code>type <a href='../std/ops/trait.Sub.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>-</code> operator</p>
</div><h4 id='method.sub-3' class="method"><span id='sub.v-3' class='invisible'><code>fn <a href='../std/ops/trait.Sub.html#tymethod.sub' class='fnname'>sub</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>-</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Neg.html" title="trait std::ops::Neg">Neg</a> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#21-28' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-4' class="type"><span id='Output.t-4' class='invisible'><code>type <a href='../std/ops/trait.Neg.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Neg.html" title="trait std::ops::Neg">Neg</a>>::<a class="trait" href="../std/ops/trait.Neg.html" title="trait std::ops::Neg">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>-</code> operator</p>
</div><h4 id='method.neg' class="method"><span id='neg.v' class='invisible'><code>fn <a href='../std/ops/trait.Neg.html#tymethod.neg' class='fnname'>neg</a>(self) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Neg.html" title="trait std::ops::Neg">Neg</a>>::<a class="trait" href="../std/ops/trait.Neg.html" title="trait std::ops::Neg">Output</a></code></span></h4>
<div class='docblock'><p>The method for the unary <code>-</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Neg.html" title="trait std::ops::Neg">Neg</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#830-836' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-5' class="type"><span id='Output.t-5' class='invisible'><code>type <a href='../std/ops/trait.Neg.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>-</code> operator</p>
</div><h4 id='method.neg-1' class="method"><span id='neg.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Neg.html#tymethod.neg' class='fnname'>neg</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the unary <code>-</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-6' class="type"><span id='Output.t-6' class='invisible'><code>type <a href='../std/ops/trait.BitXor.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>^</code> operator</p>
</div><h4 id='method.bitxor' class="method"><span id='bitxor.v' class='invisible'><code>fn <a href='../std/ops/trait.BitXor.html#tymethod.bitxor' class='fnname'>bitxor</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>^</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-7' class="type"><span id='Output.t-7' class='invisible'><code>type <a href='../std/ops/trait.BitXor.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>^</code> operator</p>
</div><h4 id='method.bitxor-1' class="method"><span id='bitxor.v-1' class='invisible'><code>fn <a href='../std/ops/trait.BitXor.html#tymethod.bitxor' class='fnname'>bitxor</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>^</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1157-1162' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-8' class="type"><span id='Output.t-8' class='invisible'><code>type <a href='../std/ops/trait.BitXor.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>^</code> operator</p>
</div><h4 id='method.bitxor-2' class="method"><span id='bitxor.v-2' class='invisible'><code>fn <a href='../std/ops/trait.BitXor.html#tymethod.bitxor' class='fnname'>bitxor</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>^</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-9' class="type"><span id='Output.t-9' class='invisible'><code>type <a href='../std/ops/trait.BitXor.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>^</code> operator</p>
</div><h4 id='method.bitxor-3' class="method"><span id='bitxor.v-3' class='invisible'><code>fn <a href='../std/ops/trait.BitXor.html#tymethod.bitxor' class='fnname'>bitxor</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>^</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-10' class="type"><span id='Output.t-10' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr' class="method"><span id='shr.v' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i128.html">i128</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-11' class="type"><span id='Output.t-11' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-1' class="method"><span id='shr.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u64.html">u64</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-12' class="type"><span id='Output.t-12' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-2' class="method"><span id='shr.v-2' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-13' class="type"><span id='Output.t-13' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-3' class="method"><span id='shr.v-3' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u8.html">u8</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-14' class="type"><span id='Output.t-14' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-4' class="method"><span id='shr.v-4' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u128.html">u128</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-15' class="type"><span id='Output.t-15' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-5' class="method"><span id='shr.v-5' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.usize.html">usize</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-16' class="type"><span id='Output.t-16' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-6' class="method"><span id='shr.v-6' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-17' class="type"><span id='Output.t-17' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-7' class="method"><span id='shr.v-7' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-18' class="type"><span id='Output.t-18' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-8' class="method"><span id='shr.v-8' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i128.html">i128</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-19' class="type"><span id='Output.t-19' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-9' class="method"><span id='shr.v-9' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-20' class="type"><span id='Output.t-20' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-10' class="method"><span id='shr.v-10' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i8.html">i8</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-21' class="type"><span id='Output.t-21' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-11' class="method"><span id='shr.v-11' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-22' class="type"><span id='Output.t-22' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-12' class="method"><span id='shr.v-12' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i64.html">i64</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-23' class="type"><span id='Output.t-23' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-13' class="method"><span id='shr.v-13' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-24' class="type"><span id='Output.t-24' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-14' class="method"><span id='shr.v-14' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u16.html">u16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-25' class="type"><span id='Output.t-25' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-15' class="method"><span id='shr.v-15' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i8.html">i8</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-26' class="type"><span id='Output.t-26' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-16' class="method"><span id='shr.v-16' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-27' class="type"><span id='Output.t-27' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-17' class="method"><span id='shr.v-17' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-28' class="type"><span id='Output.t-28' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-18' class="method"><span id='shr.v-18' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-29' class="type"><span id='Output.t-29' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-19' class="method"><span id='shr.v-19' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-30' class="type"><span id='Output.t-30' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-20' class="method"><span id='shr.v-20' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.isize.html">isize</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.isize.html">isize</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-31' class="type"><span id='Output.t-31' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-21' class="method"><span id='shr.v-21' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-32' class="type"><span id='Output.t-32' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-22' class="method"><span id='shr.v-22' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-33' class="type"><span id='Output.t-33' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-23' class="method"><span id='shr.v-23' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-34' class="type"><span id='Output.t-34' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-24' class="method"><span id='shr.v-24' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u128.html">u128</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-35' class="type"><span id='Output.t-35' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-25' class="method"><span id='shr.v-25' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u128.html">u128</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-36' class="type"><span id='Output.t-36' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-26' class="method"><span id='shr.v-26' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-37' class="type"><span id='Output.t-37' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-27' class="method"><span id='shr.v-27' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u8.html">u8</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-38' class="type"><span id='Output.t-38' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-28' class="method"><span id='shr.v-28' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-39' class="type"><span id='Output.t-39' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-29' class="method"><span id='shr.v-29' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u64.html">u64</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-40' class="type"><span id='Output.t-40' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-30' class="method"><span id='shr.v-30' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i128.html">i128</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-41' class="type"><span id='Output.t-41' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-31' class="method"><span id='shr.v-31' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.usize.html">usize</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-42' class="type"><span id='Output.t-42' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-32' class="method"><span id='shr.v-32' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u32.html">u32</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-43' class="type"><span id='Output.t-43' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-33' class="method"><span id='shr.v-33' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i64.html">i64</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-44' class="type"><span id='Output.t-44' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-34' class="method"><span id='shr.v-34' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u16.html">u16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-45' class="type"><span id='Output.t-45' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-35' class="method"><span id='shr.v-35' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.usize.html">usize</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-46' class="type"><span id='Output.t-46' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-36' class="method"><span id='shr.v-36' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.isize.html">isize</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-47' class="type"><span id='Output.t-47' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-37' class="method"><span id='shr.v-37' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u32.html">u32</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-48' class="type"><span id='Output.t-48' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-38' class="method"><span id='shr.v-38' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-49' class="type"><span id='Output.t-49' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-39' class="method"><span id='shr.v-39' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.i64.html">i64</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-50' class="type"><span id='Output.t-50' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-40' class="method"><span id='shr.v-40' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u8.html">u8</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-51' class="type"><span id='Output.t-51' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-41' class="method"><span id='shr.v-41' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u64.html">u64</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-52' class="type"><span id='Output.t-52' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-42' class="method"><span id='shr.v-42' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1344-1352' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-53' class="type"><span id='Output.t-53' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-43' class="method"><span id='shr.v-43' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: <a class="primitive" href="primitive.u16.html">u16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-54' class="type"><span id='Output.t-54' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-44' class="method"><span id='shr.v-44' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-55' class="type"><span id='Output.t-55' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-45' class="method"><span id='shr.v-45' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i8.html">i8</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-56' class="type"><span id='Output.t-56' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-46' class="method"><span id='shr.v-46' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-57' class="type"><span id='Output.t-57' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>>></code> operator</p>
</div><h4 id='method.shr-47' class="method"><span id='shr.v-47' class='invisible'><code>fn <a href='../std/ops/trait.Shr.html#tymethod.shr' class='fnname'>shr</a>(self, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Shr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shr.html" title="trait std::ops::Shr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>>></code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/fmt/trait.UpperHex.html" title="trait std::fmt::UpperHex">UpperHex</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#149-153' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.fmt' class="method"><span id='fmt.v' class='invisible'><code>fn <a href='../std/fmt/trait.UpperHex.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../std/fmt/struct.Formatter.html" title="struct std::fmt::Formatter">Formatter</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.tuple.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#339-345' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-58' class="type"><span id='Output.t-58' class='invisible'><code>type <a href='../std/ops/trait.Add.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>+</code> operator</p>
</div><h4 id='method.add' class="method"><span id='add.v' class='invisible'><code>fn <a href='../std/ops/trait.Add.html#tymethod.add' class='fnname'>add</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>+</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-59' class="type"><span id='Output.t-59' class='invisible'><code>type <a href='../std/ops/trait.Add.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>+</code> operator</p>
</div><h4 id='method.add-1' class="method"><span id='add.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Add.html#tymethod.add' class='fnname'>add</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>+</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-60' class="type"><span id='Output.t-60' class='invisible'><code>type <a href='../std/ops/trait.Add.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>+</code> operator</p>
</div><h4 id='method.add-2' class="method"><span id='add.v-2' class='invisible'><code>fn <a href='../std/ops/trait.Add.html#tymethod.add' class='fnname'>add</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>+</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-61' class="type"><span id='Output.t-61' class='invisible'><code>type <a href='../std/ops/trait.Add.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>+</code> operator</p>
</div><h4 id='method.add-3' class="method"><span id='add.v-3' class='invisible'><code>fn <a href='../std/ops/trait.Add.html#tymethod.add' class='fnname'>add</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>+</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-62' class="type"><span id='Output.t-62' class='invisible'><code>type <a href='../std/ops/trait.BitOr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>|</code> operator</p>
</div><h4 id='method.bitor' class="method"><span id='bitor.v' class='invisible'><code>fn <a href='../std/ops/trait.BitOr.html#tymethod.bitor' class='fnname'>bitor</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>|</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-63' class="type"><span id='Output.t-63' class='invisible'><code>type <a href='../std/ops/trait.BitOr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>|</code> operator</p>
</div><h4 id='method.bitor-1' class="method"><span id='bitor.v-1' class='invisible'><code>fn <a href='../std/ops/trait.BitOr.html#tymethod.bitor' class='fnname'>bitor</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>|</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1070-1075' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-64' class="type"><span id='Output.t-64' class='invisible'><code>type <a href='../std/ops/trait.BitOr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>|</code> operator</p>
</div><h4 id='method.bitor-2' class="method"><span id='bitor.v-2' class='invisible'><code>fn <a href='../std/ops/trait.BitOr.html#tymethod.bitor' class='fnname'>bitor</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>|</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-65' class="type"><span id='Output.t-65' class='invisible'><code>type <a href='../std/ops/trait.BitOr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>|</code> operator</p>
</div><h4 id='method.bitor-3' class="method"><span id='bitor.v-3' class='invisible'><code>fn <a href='../std/ops/trait.BitOr.html#tymethod.bitor' class='fnname'>bitor</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>|</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/fmt/trait.LowerHex.html" title="trait std::fmt::LowerHex">LowerHex</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#149-153' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.fmt-1' class="method"><span id='fmt.v-1' class='invisible'><code>fn <a href='../std/fmt/trait.LowerHex.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../std/fmt/struct.Formatter.html" title="struct std::fmt::Formatter">Formatter</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.tuple.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.AddAssign.html" title="trait std::ops::AddAssign">AddAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1425-1429' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.add_assign' class="method"><span id='add_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.AddAssign.html#tymethod.add_assign' class='fnname'>add_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>+=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.DivAssign.html" title="trait std::ops::DivAssign">DivAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1574-1577' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.div_assign' class="method"><span id='div_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.DivAssign.html#tymethod.div_assign' class='fnname'>div_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>/=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.BitOrAssign.html" title="trait std::ops::BitOrAssign">BitOrAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1751-1754' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.bitor_assign' class="method"><span id='bitor_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.BitOrAssign.html#tymethod.bitor_assign' class='fnname'>bitor_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>|=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../core/nonzero/trait.Zeroable.html" title="trait core::nonzero::Zeroable">Zeroable</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/nonzero.rs.html#27' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/str/trait.FromStr.html" title="trait std::str::FromStr">FromStr</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2436-2441' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Err' class="type"><span id='Err.t' class='invisible'><code>type <a href='../std/str/trait.FromStr.html#associatedtype.Err' class="type">Err</a> = <a class="struct" href="../std/num/struct.ParseIntError.html" title="struct std::num::ParseIntError">ParseIntError</a></code></span></h4>
<div class='docblock'><p>The associated error which can be returned from parsing.</p>
</div><h4 id='method.from_str' class="method"><span id='from_str.v' class='invisible'><code>fn <a href='../std/str/trait.FromStr.html#tymethod.from_str' class='fnname'>from_str</a>(src: &<a class="primitive" href="primitive.str.html">str</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.ParseIntError.html" title="struct std::num::ParseIntError">ParseIntError</a>></code></span></h4>
<div class='docblock'><p>Parses a string <code>s</code> to return a value of this type. <a href="../std/str/trait.FromStr.html#tymethod.from_str">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/iter/trait.Product.html" title="trait std::iter::Product">Product</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.12.0'>1.12.0</div><a class='srclink' href='../src/core/iter/traits.rs.html#687-691' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.product' class="method"><span id='product.v' class='invisible'><code>fn <a href='../std/iter/trait.Product.html#tymethod.product' class='fnname'>product</a><I>(iter: I) -> <a class="primitive" href="primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> I: <a class="trait" href="../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a><Item = &'a <a class="primitive" href="primitive.i16.html">i16</a>>, </span></code></span></h4>
<div class='docblock'><p>Method which takes an iterator and generates <code>Self</code> from the elements by multiplying the items. <a href="../std/iter/trait.Product.html#tymethod.product">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/iter/trait.Product.html" title="trait std::iter::Product">Product</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.12.0'>1.12.0</div><a class='srclink' href='../src/core/iter/traits.rs.html#673-677' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.product-1' class="method"><span id='product.v-1' class='invisible'><code>fn <a href='../std/iter/trait.Product.html#tymethod.product' class='fnname'>product</a><I>(iter: I) -> <a class="primitive" href="primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> I: <a class="trait" href="../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a><Item = <a class="primitive" href="primitive.i16.html">i16</a>>, </span></code></span></h4>
<div class='docblock'><p>Method which takes an iterator and generates <code>Self</code> from the elements by multiplying the items. <a href="../std/iter/trait.Product.html#tymethod.product">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/fmt/trait.Binary.html" title="trait std::fmt::Binary">Binary</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#149-153' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.fmt-2' class="method"><span id='fmt.v-2' class='invisible'><code>fn <a href='../std/fmt/trait.Binary.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../std/fmt/struct.Formatter.html" title="struct std::fmt::Formatter">Formatter</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.tuple.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-66' class="type"><span id='Output.t-66' class='invisible'><code>type <a href='../std/ops/trait.BitAnd.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>&</code> operator</p>
</div><h4 id='method.bitand' class="method"><span id='bitand.v' class='invisible'><code>fn <a href='../std/ops/trait.BitAnd.html#tymethod.bitand' class='fnname'>bitand</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>&</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-67' class="type"><span id='Output.t-67' class='invisible'><code>type <a href='../std/ops/trait.BitAnd.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>&</code> operator</p>
</div><h4 id='method.bitand-1' class="method"><span id='bitand.v-1' class='invisible'><code>fn <a href='../std/ops/trait.BitAnd.html#tymethod.bitand' class='fnname'>bitand</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>&</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-68' class="type"><span id='Output.t-68' class='invisible'><code>type <a href='../std/ops/trait.BitAnd.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>&</code> operator</p>
</div><h4 id='method.bitand-2' class="method"><span id='bitand.v-2' class='invisible'><code>fn <a href='../std/ops/trait.BitAnd.html#tymethod.bitand' class='fnname'>bitand</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>&</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#986-991' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-69' class="type"><span id='Output.t-69' class='invisible'><code>type <a href='../std/ops/trait.BitAnd.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>&</code> operator</p>
</div><h4 id='method.bitand-3' class="method"><span id='bitand.v-3' class='invisible'><code>fn <a href='../std/ops/trait.BitAnd.html#tymethod.bitand' class='fnname'>bitand</a>(self, rhs: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>&</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/iter/trait.Sum.html" title="trait std::iter::Sum">Sum</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.12.0'>1.12.0</div><a class='srclink' href='../src/core/iter/traits.rs.html#680-684' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.sum' class="method"><span id='sum.v' class='invisible'><code>fn <a href='../std/iter/trait.Sum.html#tymethod.sum' class='fnname'>sum</a><I>(iter: I) -> <a class="primitive" href="primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> I: <a class="trait" href="../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a><Item = &'a <a class="primitive" href="primitive.i16.html">i16</a>>, </span></code></span></h4>
<div class='docblock'><p>Method which takes an iterator and generates <code>Self</code> from the elements by "summing up" the items. <a href="../std/iter/trait.Sum.html#tymethod.sum">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/iter/trait.Sum.html" title="trait std::iter::Sum">Sum</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.12.0'>1.12.0</div><a class='srclink' href='../src/core/iter/traits.rs.html#666-670' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.sum-1' class="method"><span id='sum.v-1' class='invisible'><code>fn <a href='../std/iter/trait.Sum.html#tymethod.sum' class='fnname'>sum</a><I>(iter: I) -> <a class="primitive" href="primitive.i16.html">i16</a> <span class="where fmt-newline">where<br> I: <a class="trait" href="../std/iter/trait.Iterator.html" title="trait std::iter::Iterator">Iterator</a><Item = <a class="primitive" href="primitive.i16.html">i16</a>>, </span></code></span></h4>
<div class='docblock'><p>Method which takes an iterator and generates <code>Self</code> from the elements by "summing up" the items. <a href="../std/iter/trait.Sum.html#tymethod.sum">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.From.html" title="trait std::convert::From">From</a><<a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><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/core/num/mod.rs.html#2687-2692' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.from' class="method"><span id='from.v' class='invisible'><code>fn <a href='../std/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(small: <a class="primitive" href="primitive.u8.html">u8</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.From.html" title="trait std::convert::From">From</a><<a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><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/core/num/mod.rs.html#2687-2692' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.from-1' class="method"><span id='from.v-1' class='invisible'><code>fn <a href='../std/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(small: <a class="primitive" href="primitive.i8.html">i8</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/fmt/trait.Octal.html" title="trait std::fmt::Octal">Octal</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#149-153' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.fmt-3' class="method"><span id='fmt.v-3' class='invisible'><code>fn <a href='../std/fmt/trait.Octal.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../std/fmt/struct.Formatter.html" title="struct std::fmt::Formatter">Formatter</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.tuple.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/hash/trait.Hash.html" title="trait std::hash::Hash">Hash</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/hash/mod.rs.html#501-511' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.hash' class="method"><span id='hash.v' class='invisible'><code>fn <a href='../std/hash/trait.Hash.html#tymethod.hash' class='fnname'>hash</a><H>(&self, state: &mut H) <span class="where fmt-newline">where<br> H: <a class="trait" href="../std/hash/trait.Hasher.html" title="trait std::hash::Hasher">Hasher</a>, </span></code></span></h4>
<div class='docblock'><p>Feeds this value into the given [<code>Hasher</code>]. <a href="../std/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'><code>fn <a href='../std/hash/trait.Hash.html#method.hash_slice' class='fnname'>hash_slice</a><H>(data: <a class="primitive" href="primitive.slice.html">&[</a><a class="primitive" href="primitive.i16.html">i16</a><a class="primitive" href="primitive.slice.html">]</a>, state: &mut H) <span class="where fmt-newline">where<br> H: <a class="trait" href="../std/hash/trait.Hasher.html" title="trait std::hash::Hasher">Hasher</a>, </span></code></span></h4>
<div class='docblock'><p>Feeds a slice of this type into the given [<code>Hasher</code>]. <a href="../std/hash/trait.Hash.html#method.hash_slice">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#667-672' title='goto source code'>[src]</a></span></h3>
<div class='docblock'><p>This operation rounds towards zero, truncating any
fractional part of the exact result.</p>
</div><div class='impl-items'><h4 id='associatedtype.Output-70' class="type"><span id='Output.t-70' class='invisible'><code>type <a href='../std/ops/trait.Div.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>/</code> operator</p>
</div><h4 id='method.div' class="method"><span id='div.v' class='invisible'><code>fn <a href='../std/ops/trait.Div.html#tymethod.div' class='fnname'>div</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>/</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-71' class="type"><span id='Output.t-71' class='invisible'><code>type <a href='../std/ops/trait.Div.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>/</code> operator</p>
</div><h4 id='method.div-1' class="method"><span id='div.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Div.html#tymethod.div' class='fnname'>div</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>/</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-72' class="type"><span id='Output.t-72' class='invisible'><code>type <a href='../std/ops/trait.Div.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>/</code> operator</p>
</div><h4 id='method.div-2' class="method"><span id='div.v-2' class='invisible'><code>fn <a href='../std/ops/trait.Div.html#tymethod.div' class='fnname'>div</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>/</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-73' class="type"><span id='Output.t-73' class='invisible'><code>type <a href='../std/ops/trait.Div.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>/</code> operator</p>
</div><h4 id='method.div-3' class="method"><span id='div.v-3' class='invisible'><code>fn <a href='../std/ops/trait.Div.html#tymethod.div' class='fnname'>div</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>/</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/clone/trait.Clone.html" title="trait std::clone::Clone">Clone</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/clone.rs.html#143-147' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.clone' class="method"><span id='clone.v' class='invisible'><code>fn <a href='../std/clone/trait.Clone.html#tymethod.clone' class='fnname'>clone</a>(&self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Returns a deep copy of the value.</p>
</div><h4 id='method.clone_from' class="method"><span id='clone_from.v' class='invisible'><code>fn <a href='../std/clone/trait.Clone.html#method.clone_from' class='fnname'>clone_from</a>(&mut self, source: &Self)</code></span></h4>
<div class='docblock'><p>Performs copy-assignment from <code>source</code>. <a href="../std/clone/trait.Clone.html#method.clone_from">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/default/trait.Default.html" title="trait std::default::Default">Default</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/default.rs.html#131-134' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.default' class="method"><span id='default.v' class='invisible'><code>fn <a href='../std/default/trait.Default.html#tymethod.default' class='fnname'>default</a>() -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>Returns the "default value" for a type. <a href="../std/default/trait.Default.html#tymethod.default">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/iter/trait.Step.html" title="trait std::iter::Step">Step</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/range.rs.html#119-182' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.step' class="method"><span id='step.v' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.step' class='fnname'>step</a>(&self, by: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i16.html">i16</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>step_trait </code><a href="https://github.com/rust-lang/rust/issues/42168">#42168</a>)</summary><p>likely to be replaced by finer-grained traits</p>
</details></div></div><div class='docblock'><p>Steps <code>self</code> if possible.</p>
</div><h4 id='method.steps_between' class="method"><span id='steps_between.v' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.steps_between' class='fnname'>steps_between</a>(start: &<a class="primitive" href="primitive.i16.html">i16</a>, end: &<a class="primitive" href="primitive.i16.html">i16</a>, by: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.usize.html">usize</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>step_trait </code><a href="https://github.com/rust-lang/rust/issues/42168">#42168</a>)</summary><p>likely to be replaced by finer-grained traits</p>
</details></div></div><div class='docblock'><p>Returns the number of steps between two step objects. The count is inclusive of <code>start</code> and exclusive of <code>end</code>. <a href="../std/iter/trait.Step.html#tymethod.steps_between">Read more</a></p>
</div><h4 id='method.is_negative-1' class="method"><span id='is_negative.v-1' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.is_negative' class='fnname'>is_negative</a>(&self) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>step_trait </code><a href="https://github.com/rust-lang/rust/issues/42168">#42168</a>)</summary><p>likely to be replaced by finer-grained traits</p>
</details></div></div><div class='docblock'><p>Tests whether this step is negative or not (going backwards)</p>
</div><h4 id='method.replace_one' class="method"><span id='replace_one.v' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.replace_one' class='fnname'>replace_one</a>(&mut self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>step_trait </code><a href="https://github.com/rust-lang/rust/issues/42168">#42168</a>)</summary><p>likely to be replaced by finer-grained traits</p>
</details></div></div><div class='docblock'><p>Replaces this step with <code>1</code>, returning itself</p>
</div><h4 id='method.replace_zero' class="method"><span id='replace_zero.v' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.replace_zero' class='fnname'>replace_zero</a>(&mut self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>step_trait </code><a href="https://github.com/rust-lang/rust/issues/42168">#42168</a>)</summary><p>likely to be replaced by finer-grained traits</p>
</details></div></div><div class='docblock'><p>Replaces this step with <code>0</code>, returning itself</p>
</div><h4 id='method.add_one' class="method"><span id='add_one.v' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.add_one' class='fnname'>add_one</a>(&self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>step_trait </code><a href="https://github.com/rust-lang/rust/issues/42168">#42168</a>)</summary><p>likely to be replaced by finer-grained traits</p>
</details></div></div><div class='docblock'><p>Adds one to this step, returning the result</p>
</div><h4 id='method.sub_one' class="method"><span id='sub_one.v' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.sub_one' class='fnname'>sub_one</a>(&self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>step_trait </code><a href="https://github.com/rust-lang/rust/issues/42168">#42168</a>)</summary><p>likely to be replaced by finer-grained traits</p>
</details></div></div><div class='docblock'><p>Subtracts one to this step, returning the result</p>
</div><h4 id='method.steps_between_by_one' class="method"><span id='steps_between_by_one.v' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.steps_between_by_one' class='fnname'>steps_between_by_one</a>(start: &<a class="primitive" href="primitive.i16.html">i16</a>, end: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.usize.html">usize</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>step_trait </code><a href="https://github.com/rust-lang/rust/issues/42168">#42168</a>)</summary><p>likely to be replaced by finer-grained traits</p>
</details></div></div><div class='docblock'><p>Same as <code>steps_between</code>, but with a <code>by</code> of 1</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/fmt/trait.Display.html" title="trait std::fmt::Display">Display</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#200-259' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.fmt-4' class="method"><span id='fmt.v-4' class='invisible'><code>fn <a href='../std/fmt/trait.Display.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../std/fmt/struct.Formatter.html" title="struct std::fmt::Formatter">Formatter</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.tuple.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span></h4>
<div class='docblock'><p>Formats the value using the given formatter. <a href="../std/fmt/trait.Display.html#tymethod.fmt">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/cmp/trait.PartialEq.html" title="trait std::cmp::PartialEq">PartialEq</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#719-724' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.eq' class="method"><span id='eq.v' class='invisible'><code>fn <a href='../std/cmp/trait.PartialEq.html#tymethod.eq' class='fnname'>eq</a>(&self, other: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='docblock'><p>This method tests for <code>self</code> and <code>other</code> values to be equal, and is used by <code>==</code>. <a href="../std/cmp/trait.PartialEq.html#tymethod.eq">Read more</a></p>
</div><h4 id='method.ne' class="method"><span id='ne.v' class='invisible'><code>fn <a href='../std/cmp/trait.PartialEq.html#method.ne' class='fnname'>ne</a>(&self, other: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='docblock'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.SubAssign.html" title="trait std::ops::SubAssign">SubAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1482-1486' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.sub_assign' class="method"><span id='sub_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.SubAssign.html#tymethod.sub_assign' class='fnname'>sub_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>-=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.RemAssign.html" title="trait std::ops::RemAssign">RemAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1619-1622' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.rem_assign' class="method"><span id='rem_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.RemAssign.html#tymethod.rem_assign' class='fnname'>rem_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>%=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/cmp/trait.Ord.html" title="trait std::cmp::Ord">Ord</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#811-818' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.cmp' class="method"><span id='cmp.v' class='invisible'><code>fn <a href='../std/cmp/trait.Ord.html#tymethod.cmp' class='fnname'>cmp</a>(&self, other: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/cmp/enum.Ordering.html" title="enum std::cmp::Ordering">Ordering</a></code></span></h4>
<div class='docblock'><p>This method returns an <code>Ordering</code> between <code>self</code> and <code>other</code>. <a href="../std/cmp/trait.Ord.html#tymethod.cmp">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.BitXorAssign.html" title="trait std::ops::BitXorAssign">BitXorAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1796-1799' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.bitxor_assign' class="method"><span id='bitxor_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.BitXorAssign.html#tymethod.bitxor_assign' class='fnname'>bitxor_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>^=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Not.html" title="trait std::ops::Not">Not</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#902-907' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-74' class="type"><span id='Output.t-74' class='invisible'><code>type <a href='../std/ops/trait.Not.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>!</code> operator</p>
</div><h4 id='method.not' class="method"><span id='not.v' class='invisible'><code>fn <a href='../std/ops/trait.Not.html#tymethod.not' class='fnname'>not</a>(self) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the unary <code>!</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Not.html" title="trait std::ops::Not">Not</a> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#21-28' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-75' class="type"><span id='Output.t-75' class='invisible'><code>type <a href='../std/ops/trait.Not.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Not.html" title="trait std::ops::Not">Not</a>>::<a class="trait" href="../std/ops/trait.Not.html" title="trait std::ops::Not">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>!</code> operator</p>
</div><h4 id='method.not-1' class="method"><span id='not.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Not.html#tymethod.not' class='fnname'>not</a>(self) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Not.html" title="trait std::ops::Not">Not</a>>::<a class="trait" href="../std/ops/trait.Not.html" title="trait std::ops::Not">Output</a></code></span></h4>
<div class='docblock'><p>The method for the unary <code>!</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/fmt/trait.Debug.html" title="trait std::fmt::Debug">Debug</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#160-164' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.fmt-5' class="method"><span id='fmt.v-5' class='invisible'><code>fn <a href='../std/fmt/trait.Debug.html#tymethod.fmt' class='fnname'>fmt</a>(&self, f: &mut <a class="struct" href="../std/fmt/struct.Formatter.html" title="struct std::fmt::Formatter">Formatter</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.tuple.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2504-2515' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error' class="type"><span id='Error.t' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from' class="method"><span id='try_from.v' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2472-2484' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-1' class="type"><span id='Error.t-1' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-1' class="method"><span id='try_from.v-1' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2504-2515' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-2' class="type"><span id='Error.t-2' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-2' class="method"><span id='try_from.v-2' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.usize.html">usize</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2472-2484' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-3' class="type"><span id='Error.t-3' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-3' class="method"><span id='try_from.v-3' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.i8.html">i8</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2504-2515' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-4' class="type"><span id='Error.t-4' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-4' class="method"><span id='try_from.v-4' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.u16.html">u16</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2472-2484' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-5' class="type"><span id='Error.t-5' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-5' class="method"><span id='try_from.v-5' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.i64.html">i64</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2472-2484' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-6' class="type"><span id='Error.t-6' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-6' class="method"><span id='try_from.v-6' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2504-2515' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-7' class="type"><span id='Error.t-7' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-7' class="method"><span id='try_from.v-7' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.u8.html">u8</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2504-2515' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-8' class="type"><span id='Error.t-8' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-8' class="method"><span id='try_from.v-8' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.u128.html">u128</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2472-2484' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-9' class="type"><span id='Error.t-9' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-9' class="method"><span id='try_from.v-9' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.isize.html">isize</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2472-2484' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-10' class="type"><span id='Error.t-10' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-10' class="method"><span id='try_from.v-10' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.i128.html">i128</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/convert/trait.TryFrom.html" title="trait std::convert::TryFrom">TryFrom</a><<a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2504-2515' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Error-11' class="type"><span id='Error.t-11' class='invisible'><code>type <a href='../std/convert/trait.TryFrom.html#associatedtype.Error' class="type">Error</a> = <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>The type returned in the event of a conversion error.</p>
</div><h4 id='method.try_from-11' class="method"><span id='try_from.v-11' class='invisible'><code>fn <a href='../std/convert/trait.TryFrom.html#tymethod.try_from' class='fnname'>try_from</a>(u: <a class="primitive" href="primitive.u64.html">u64</a>) -> <a class="enum" href="../std/result/enum.Result.html" title="enum std::result::Result">Result</a><<a class="primitive" href="primitive.i16.html">i16</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>try_from </code><a href="https://github.com/rust-lang/rust/issues/33417">#33417</a>)</div></div><div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/cmp/trait.PartialOrd.html" title="trait std::cmp::PartialOrd">PartialOrd</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#795-808' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.partial_cmp' class="method"><span id='partial_cmp.v' class='invisible'><code>fn <a href='../std/cmp/trait.PartialOrd.html#tymethod.partial_cmp' class='fnname'>partial_cmp</a>(&self, other: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="enum" href="../std/cmp/enum.Ordering.html" title="enum std::cmp::Ordering">Ordering</a>></code></span></h4>
<div class='docblock'><p>This method returns an ordering between <code>self</code> and <code>other</code> values if one exists. <a href="../std/cmp/trait.PartialOrd.html#tymethod.partial_cmp">Read more</a></p>
</div><h4 id='method.lt' class="method"><span id='lt.v' class='invisible'><code>fn <a href='../std/cmp/trait.PartialOrd.html#method.lt' class='fnname'>lt</a>(&self, other: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='docblock'><p>This method tests less than (for <code>self</code> and <code>other</code>) and is used by the <code><</code> operator. <a href="../std/cmp/trait.PartialOrd.html#method.lt">Read more</a></p>
</div><h4 id='method.le' class="method"><span id='le.v' class='invisible'><code>fn <a href='../std/cmp/trait.PartialOrd.html#method.le' class='fnname'>le</a>(&self, other: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='docblock'><p>This method tests less than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code><=</code> operator. <a href="../std/cmp/trait.PartialOrd.html#method.le">Read more</a></p>
</div><h4 id='method.ge' class="method"><span id='ge.v' class='invisible'><code>fn <a href='../std/cmp/trait.PartialOrd.html#method.ge' class='fnname'>ge</a>(&self, other: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='docblock'><p>This method tests greater than or equal to (for <code>self</code> and <code>other</code>) and is used by the <code>>=</code> operator. <a href="../std/cmp/trait.PartialOrd.html#method.ge">Read more</a></p>
</div><h4 id='method.gt' class="method"><span id='gt.v' class='invisible'><code>fn <a href='../std/cmp/trait.PartialOrd.html#method.gt' class='fnname'>gt</a>(&self, other: &<a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span></h4>
<div class='docblock'><p>This method tests greater than (for <code>self</code> and <code>other</code>) and is used by the <code>></code> operator. <a href="../std/cmp/trait.PartialOrd.html#method.gt">Read more</a></p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign' class="method"><span id='shr_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.i8.html">i8</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-1' class="method"><span id='shr_assign.v-1' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.usize.html">usize</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-2' class="method"><span id='shr_assign.v-2' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.i64.html">i64</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-3' class="method"><span id='shr_assign.v-3' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.i128.html">i128</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-4' class="method"><span id='shr_assign.v-4' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.u8.html">u8</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-5' class="method"><span id='shr_assign.v-5' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.u16.html">u16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-6' class="method"><span id='shr_assign.v-6' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.isize.html">isize</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-7' class="method"><span id='shr_assign.v-7' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.u128.html">u128</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-8' class="method"><span id='shr_assign.v-8' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.u32.html">u32</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-9' class="method"><span id='shr_assign.v-9' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.u64.html">u64</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-10' class="method"><span id='shr_assign.v-10' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><<a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1907-1913' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-11' class="method"><span id='shr_assign.v-11' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: <a class="primitive" href="primitive.i32.html">i32</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>>>=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-76' class="type"><span id='Output.t-76' class='invisible'><code>type <a href='../std/ops/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>*</code> operator</p>
</div><h4 id='method.mul' class="method"><span id='mul.v' class='invisible'><code>fn <a href='../std/ops/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>*</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-77' class="type"><span id='Output.t-77' class='invisible'><code>type <a href='../std/ops/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>*</code> operator</p>
</div><h4 id='method.mul-1' class="method"><span id='mul.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>*</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-78' class="type"><span id='Output.t-78' class='invisible'><code>type <a href='../std/ops/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>*</code> operator</p>
</div><h4 id='method.mul-2' class="method"><span id='mul.v-2' class='invisible'><code>fn <a href='../std/ops/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>*</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#536-542' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-79' class="type"><span id='Output.t-79' class='invisible'><code>type <a href='../std/ops/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>*</code> operator</p>
</div><h4 id='method.mul-3' class="method"><span id='mul.v-3' class='invisible'><code>fn <a href='../std/ops/trait.Mul.html#tymethod.mul' class='fnname'>mul</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>*</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-80' class="type"><span id='Output.t-80' class='invisible'><code>type <a href='../std/ops/trait.Rem.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>%</code> operator</p>
</div><h4 id='method.rem' class="method"><span id='rem.v' class='invisible'><code>fn <a href='../std/ops/trait.Rem.html#tymethod.rem' class='fnname'>rem</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>%</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#747-752' title='goto source code'>[src]</a></span></h3>
<div class='docblock'><p>This operation satisfies <code>n % d == n - (n / d) * d</code>. The
result has the same sign as the left operand.</p>
</div><div class='impl-items'><h4 id='associatedtype.Output-81' class="type"><span id='Output.t-81' class='invisible'><code>type <a href='../std/ops/trait.Rem.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>%</code> operator</p>
</div><h4 id='method.rem-1' class="method"><span id='rem.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Rem.html#tymethod.rem' class='fnname'>rem</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code>%</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-82' class="type"><span id='Output.t-82' class='invisible'><code>type <a href='../std/ops/trait.Rem.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>%</code> operator</p>
</div><h4 id='method.rem-2' class="method"><span id='rem.v-2' class='invisible'><code>fn <a href='../std/ops/trait.Rem.html#tymethod.rem' class='fnname'>rem</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>%</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-83' class="type"><span id='Output.t-83' class='invisible'><code>type <a href='../std/ops/trait.Rem.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code>%</code> operator</p>
</div><h4 id='method.rem-3' class="method"><span id='rem.v-3' class='invisible'><code>fn <a href='../std/ops/trait.Rem.html#tymethod.rem' class='fnname'>rem</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code>%</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-84' class="type"><span id='Output.t-84' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl' class="method"><span id='shl.v' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u8.html">u8</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u8.html">u8</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-85' class="type"><span id='Output.t-85' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-1' class="method"><span id='shl.v-1' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.usize.html">usize</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-86' class="type"><span id='Output.t-86' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-2' class="method"><span id='shl.v-2' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-87' class="type"><span id='Output.t-87' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-3' class="method"><span id='shl.v-3' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-88' class="type"><span id='Output.t-88' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-4' class="method"><span id='shl.v-4' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u16.html">u16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i128.html">i128</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-89' class="type"><span id='Output.t-89' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-5' class="method"><span id='shl.v-5' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-90' class="type"><span id='Output.t-90' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-6' class="method"><span id='shl.v-6' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-91' class="type"><span id='Output.t-91' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-7' class="method"><span id='shl.v-7' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-92' class="type"><span id='Output.t-92' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-8' class="method"><span id='shl.v-8' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-93' class="type"><span id='Output.t-93' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-9' class="method"><span id='shl.v-9' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.isize.html">isize</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-94' class="type"><span id='Output.t-94' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-10' class="method"><span id='shl.v-10' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-95' class="type"><span id='Output.t-95' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-11' class="method"><span id='shl.v-11' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i64.html">i64</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-96' class="type"><span id='Output.t-96' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-12' class="method"><span id='shl.v-12' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u128.html">u128</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-97' class="type"><span id='Output.t-97' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-13' class="method"><span id='shl.v-13' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i64.html">i64</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-98' class="type"><span id='Output.t-98' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-14' class="method"><span id='shl.v-14' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u32.html">u32</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-99' class="type"><span id='Output.t-99' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-15' class="method"><span id='shl.v-15' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-100' class="type"><span id='Output.t-100' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-16' class="method"><span id='shl.v-16' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u32.html">u32</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-101' class="type"><span id='Output.t-101' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-17' class="method"><span id='shl.v-17' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u32.html">u32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-102' class="type"><span id='Output.t-102' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-18' class="method"><span id='shl.v-18' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u16.html">u16</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-103' class="type"><span id='Output.t-103' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-19' class="method"><span id='shl.v-19' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u16.html">u16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-104' class="type"><span id='Output.t-104' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-20' class="method"><span id='shl.v-20' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u16.html">u16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-105' class="type"><span id='Output.t-105' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-21' class="method"><span id='shl.v-21' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i16.html">i16</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-106' class="type"><span id='Output.t-106' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-22' class="method"><span id='shl.v-22' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-107' class="type"><span id='Output.t-107' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-23' class="method"><span id='shl.v-23' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-108' class="type"><span id='Output.t-108' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-24' class="method"><span id='shl.v-24' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i16.html">i16</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-109' class="type"><span id='Output.t-109' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-25' class="method"><span id='shl.v-25' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-110' class="type"><span id='Output.t-110' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-26' class="method"><span id='shl.v-26' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-111' class="type"><span id='Output.t-111' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-27' class="method"><span id='shl.v-27' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-112' class="type"><span id='Output.t-112' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-28' class="method"><span id='shl.v-28' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i8.html">i8</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-113' class="type"><span id='Output.t-113' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-29' class="method"><span id='shl.v-29' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.isize.html">isize</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-114' class="type"><span id='Output.t-114' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-30' class="method"><span id='shl.v-30' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i128.html">i128</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-115' class="type"><span id='Output.t-115' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-31' class="method"><span id='shl.v-31' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i128.html">i128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-116' class="type"><span id='Output.t-116' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-32' class="method"><span id='shl.v-32' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i128.html">i128</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-117' class="type"><span id='Output.t-117' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-33' class="method"><span id='shl.v-33' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-118' class="type"><span id='Output.t-118' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-34' class="method"><span id='shl.v-34' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.usize.html">usize</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u128.html">u128</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-119' class="type"><span id='Output.t-119' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-35' class="method"><span id='shl.v-35' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u64.html">u64</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-120' class="type"><span id='Output.t-120' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-36' class="method"><span id='shl.v-36' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-121' class="type"><span id='Output.t-121' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-37' class="method"><span id='shl.v-37' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-122' class="type"><span id='Output.t-122' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-38' class="method"><span id='shl.v-38' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u64.html">u64</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.i8.html">i8</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-123' class="type"><span id='Output.t-123' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-39' class="method"><span id='shl.v-39' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i8.html">i8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u8.html">u8</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-124' class="type"><span id='Output.t-124' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-40' class="method"><span id='shl.v-40' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u8.html">u8</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.usize.html">usize</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-125' class="type"><span id='Output.t-125' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-41' class="method"><span id='shl.v-41' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.usize.html">usize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.isize.html">isize</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-126' class="type"><span id='Output.t-126' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-42' class="method"><span id='shl.v-42' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.isize.html">isize</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#51-58' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-127' class="type"><span id='Output.t-127' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-43' class="method"><span id='shl.v-43' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a, 'b> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><&'a <a class="primitive" href="primitive.u64.html">u64</a>> for &'b <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#61-68' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-128' class="type"><span id='Output.t-128' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-44' class="method"><span id='shl.v-44' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: &'a <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u64.html">u64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u128.html">u128</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-129' class="type"><span id='Output.t-129' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-45' class="method"><span id='shl.v-45' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.u128.html">u128</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops.rs.html#1240-1248' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-130' class="type"><span id='Output.t-130' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-46' class="method"><span id='shl.v-46' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i8.html">i8</a>) -> <a class="primitive" href="primitive.i16.html">i16</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i64.html">i64</a>> for &'a <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#41-48' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='associatedtype.Output-131' class="type"><span id='Output.t-131' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The resulting type after applying the <code><<</code> operator</p>
</div><h4 id='method.shl-47' class="method"><span id='shl.v-47' class='invisible'><code>fn <a href='../std/ops/trait.Shl.html#tymethod.shl' class='fnname'>shl</a>(self, other: <a class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i16.html">i16</a> as <a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Shl</a><<a class="primitive" href="primitive.i64.html">i64</a>>>::<a class="trait" href="../std/ops/trait.Shl.html" title="trait std::ops::Shl">Output</a></code></span></h4>
<div class='docblock'><p>The method for the <code><<</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.MulAssign.html" title="trait std::ops::MulAssign">MulAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1528-1532' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.mul_assign' class="method"><span id='mul_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.MulAssign.html#tymethod.mul_assign' class='fnname'>mul_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>*=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/cmp/trait.Eq.html" title="trait std::cmp::Eq">Eq</a> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#743' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.BitAndAssign.html" title="trait std::ops::BitAndAssign">BitAndAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1706-1709' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.bitand_assign' class="method"><span id='bitand_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.BitAndAssign.html#tymethod.bitand_assign' class='fnname'>bitand_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code>&=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign' class="method"><span id='shl_assign.v' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.i64.html">i64</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-1' class="method"><span id='shl_assign.v-1' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.u16.html">u16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-2' class="method"><span id='shl_assign.v-2' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.i8.html">i8</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-3' class="method"><span id='shl_assign.v-3' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.usize.html">usize</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-4' class="method"><span id='shl_assign.v-4' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.u128.html">u128</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-5' class="method"><span id='shl_assign.v-5' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.u32.html">u32</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-6' class="method"><span id='shl_assign.v-6' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.u64.html">u64</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-7' class="method"><span id='shl_assign.v-7' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.isize.html">isize</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-8' class="method"><span id='shl_assign.v-8' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.i128.html">i128</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-9' class="method"><span id='shl_assign.v-9' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.u8.html">u8</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-10' class="method"><span id='shl_assign.v-10' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.i16.html">i16</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</div></div><h3 class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><<a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i16.html">i16</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.8.0'>1.8.0</div><a class='srclink' href='../src/core/ops.rs.html#1841-1847' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-11' class="method"><span id='shl_assign.v-11' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: <a class="primitive" href="primitive.i32.html">i32</a>)</code></span></h4>
<div class='docblock'><p>The method for the <code><<=</code> operator</p>
</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>?</dt>
<dd>Show this help dialog</dd>
<dt>S</dt>
<dd>Focus the search field</dd>
<dt>⇤</dt>
<dd>Move up in search results</dd>
<dt>⇥</dt>
<dd>Move down in search results</dd>
<dt>⏎</dt>
<dd>Go to active search result</dd>
<dt>+</dt>
<dd>Collapse/expand 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>
</div>
</div>
</aside>
<script>
window.rootPath = "../";
window.currentCrate = "std";
</script>
<script src="../main.js"></script>
<script defer src="../search-index.js"></script>
</body>
</html>
distrib
>
Mageia
>
6
>
armv7hl
>
media
>
core-updates
>
by-pkgid
>
564935689ab5527f955e5449ded02799
>
files
>
4790
