<!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 `i32` primitive in crate `std`.">
<meta name="keywords" content="rust, rustlang, rust-lang, i32">
<title>i32 - Rust</title>
<link rel="stylesheet" type="text/css" href="../normalize.css">
<link rel="stylesheet" type="text/css" href="../rustdoc.css" id="mainThemeStyle">
<link rel="stylesheet" type="text/css" href="../dark.css">
<link rel="stylesheet" type="text/css" href="../main.css" id="themeStyle">
<script src="../storage.js"></script>
<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">
<div class="sidebar-menu">☰</div>
<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 i32</p><div class="sidebar-elems"><div class="block items"><a class="sidebar-title" href="#methods">Methods</a><div class="sidebar-links"><a href="#method.min_value">min_value</a><a href="#method.max_value">max_value</a><a href="#method.from_str_radix">from_str_radix</a><a href="#method.count_ones">count_ones</a><a href="#method.count_zeros">count_zeros</a><a href="#method.leading_zeros">leading_zeros</a><a href="#method.trailing_zeros">trailing_zeros</a><a href="#method.rotate_left">rotate_left</a><a href="#method.rotate_right">rotate_right</a><a href="#method.swap_bytes">swap_bytes</a><a href="#method.from_be">from_be</a><a href="#method.from_le">from_le</a><a href="#method.to_be">to_be</a><a href="#method.to_le">to_le</a><a href="#method.checked_add">checked_add</a><a href="#method.checked_sub">checked_sub</a><a href="#method.checked_mul">checked_mul</a><a href="#method.checked_div">checked_div</a><a href="#method.checked_rem">checked_rem</a><a href="#method.checked_neg">checked_neg</a><a href="#method.checked_shl">checked_shl</a><a href="#method.checked_shr">checked_shr</a><a href="#method.checked_abs">checked_abs</a><a href="#method.saturating_add">saturating_add</a><a href="#method.saturating_sub">saturating_sub</a><a href="#method.saturating_mul">saturating_mul</a><a href="#method.wrapping_add">wrapping_add</a><a href="#method.wrapping_sub">wrapping_sub</a><a href="#method.wrapping_mul">wrapping_mul</a><a href="#method.wrapping_div">wrapping_div</a><a href="#method.wrapping_rem">wrapping_rem</a><a href="#method.wrapping_neg">wrapping_neg</a><a href="#method.wrapping_shl">wrapping_shl</a><a href="#method.wrapping_shr">wrapping_shr</a><a href="#method.wrapping_abs">wrapping_abs</a><a href="#method.overflowing_add">overflowing_add</a><a href="#method.overflowing_sub">overflowing_sub</a><a href="#method.overflowing_mul">overflowing_mul</a><a href="#method.overflowing_div">overflowing_div</a><a href="#method.overflowing_rem">overflowing_rem</a><a href="#method.overflowing_neg">overflowing_neg</a><a href="#method.overflowing_shl">overflowing_shl</a><a href="#method.overflowing_shr">overflowing_shr</a><a href="#method.overflowing_abs">overflowing_abs</a><a href="#method.pow">pow</a><a href="#method.abs">abs</a><a href="#method.signum">signum</a><a href="#method.is_positive">is_positive</a><a href="#method.is_negative">is_negative</a></div><a class="sidebar-title" href="#implementations">Trait Implementations</a><div class="sidebar-links"><a href="#impl-Binary">Binary</a><a href="#impl-FromStr">FromStr</a><a href="#impl-Sub%3C%26%27a%20i32%3E">Sub<&'a i32></a><a href="#impl-Sub%3Ci32%3E">Sub<i32></a><a href="#impl-Shr%3Cisize%3E">Shr<isize></a><a href="#impl-Shr%3Cu8%3E">Shr<u8></a><a href="#impl-Shr%3Cu16%3E">Shr<u16></a><a href="#impl-Shr%3C%26%27a%20i16%3E">Shr<&'a i16></a><a href="#impl-Shr%3Ci64%3E">Shr<i64></a><a href="#impl-Shr%3C%26%27a%20u64%3E">Shr<&'a u64></a><a href="#impl-Shr%3Cu64%3E">Shr<u64></a><a href="#impl-Shr%3C%26%27a%20i128%3E">Shr<&'a i128></a><a href="#impl-Shr%3C%26%27a%20i8%3E">Shr<&'a i8></a><a href="#impl-Shr%3C%26%27a%20u8%3E">Shr<&'a u8></a><a href="#impl-Shr%3C%26%27a%20i32%3E">Shr<&'a i32></a><a href="#impl-Shr%3Ci16%3E">Shr<i16></a><a href="#impl-Shr%3C%26%27a%20u16%3E">Shr<&'a u16></a><a href="#impl-Shr%3Ci8%3E">Shr<i8></a><a href="#impl-Shr%3C%26%27a%20u128%3E">Shr<&'a u128></a><a href="#impl-Shr%3Ci128%3E">Shr<i128></a><a href="#impl-Shr%3Cu32%3E">Shr<u32></a><a href="#impl-Shr%3Ci32%3E">Shr<i32></a><a href="#impl-Shr%3Cu128%3E">Shr<u128></a><a href="#impl-Shr%3C%26%27a%20isize%3E">Shr<&'a isize></a><a href="#impl-Shr%3C%26%27a%20i64%3E">Shr<&'a i64></a><a href="#impl-Shr%3C%26%27a%20u32%3E">Shr<&'a u32></a><a href="#impl-Shr%3C%26%27a%20usize%3E">Shr<&'a usize></a><a href="#impl-Shr%3Cusize%3E">Shr<usize></a><a href="#impl-Debug">Debug</a><a href="#impl-BitXor%3Ci32%3E">BitXor<i32></a><a href="#impl-BitXor%3C%26%27a%20i32%3E">BitXor<&'a i32></a><a href="#impl-Not">Not</a><a href="#impl-Rem%3Ci32%3E">Rem<i32></a><a href="#impl-Rem%3C%26%27a%20i32%3E">Rem<&'a i32></a><a href="#impl-Product%3C%26%27a%20i32%3E">Product<&'a i32></a><a href="#impl-Product%3Ci32%3E">Product<i32></a><a href="#impl-UpperHex">UpperHex</a><a href="#impl-Step">Step</a><a href="#impl-Mul%3Ci32%3E">Mul<i32></a><a href="#impl-Mul%3C%26%27a%20i32%3E">Mul<&'a i32></a><a href="#impl-Octal">Octal</a><a href="#impl-Shl%3Cusize%3E">Shl<usize></a><a href="#impl-Shl%3Cisize%3E">Shl<isize></a><a href="#impl-Shl%3C%26%27a%20u128%3E">Shl<&'a u128></a><a href="#impl-Shl%3C%26%27a%20isize%3E">Shl<&'a isize></a><a href="#impl-Shl%3C%26%27a%20usize%3E">Shl<&'a usize></a><a href="#impl-Shl%3C%26%27a%20u32%3E">Shl<&'a u32></a><a href="#impl-Shl%3Ci64%3E">Shl<i64></a><a href="#impl-Shl%3C%26%27a%20u64%3E">Shl<&'a u64></a><a href="#impl-Shl%3C%26%27a%20i32%3E">Shl<&'a i32></a><a href="#impl-Shl%3Ci32%3E">Shl<i32></a><a href="#impl-Shl%3C%26%27a%20i64%3E">Shl<&'a i64></a><a href="#impl-Shl%3Ci128%3E">Shl<i128></a><a href="#impl-Shl%3Cu128%3E">Shl<u128></a><a href="#impl-Shl%3C%26%27a%20i16%3E">Shl<&'a i16></a><a href="#impl-Shl%3Cu16%3E">Shl<u16></a><a href="#impl-Shl%3Ci16%3E">Shl<i16></a><a href="#impl-Shl%3C%26%27a%20i8%3E">Shl<&'a i8></a><a href="#impl-Shl%3C%26%27a%20i128%3E">Shl<&'a i128></a><a href="#impl-Shl%3Cu8%3E">Shl<u8></a><a href="#impl-Shl%3Ci8%3E">Shl<i8></a><a href="#impl-Shl%3C%26%27a%20u16%3E">Shl<&'a u16></a><a href="#impl-Shl%3Cu32%3E">Shl<u32></a><a href="#impl-Shl%3Cu64%3E">Shl<u64></a><a href="#impl-Shl%3C%26%27a%20u8%3E">Shl<&'a u8></a><a href="#impl-TryFrom%3Ci128%3E">TryFrom<i128></a><a href="#impl-TryFrom%3Cisize%3E">TryFrom<isize></a><a href="#impl-TryFrom%3Cu128%3E">TryFrom<u128></a><a href="#impl-TryFrom%3Ci64%3E">TryFrom<i64></a><a href="#impl-TryFrom%3Cu32%3E">TryFrom<u32></a><a href="#impl-TryFrom%3Cu64%3E">TryFrom<u64></a><a href="#impl-TryFrom%3Cusize%3E">TryFrom<usize></a><a href="#impl-Zeroable">Zeroable</a><a href="#impl-BitAnd%3C%26%27a%20i32%3E">BitAnd<&'a i32></a><a href="#impl-BitAnd%3Ci32%3E">BitAnd<i32></a><a href="#impl-Hash">Hash</a><a href="#impl-Default">Default</a><a href="#impl-PartialOrd%3Ci32%3E">PartialOrd<i32></a><a href="#impl-Ord">Ord</a><a href="#impl-ShlAssign%3C%26%27a%20i32%3E">ShlAssign<&'a i32></a><a href="#impl-ShlAssign%3Cu8%3E">ShlAssign<u8></a><a href="#impl-ShlAssign%3Ci16%3E">ShlAssign<i16></a><a href="#impl-ShlAssign%3Cusize%3E">ShlAssign<usize></a><a href="#impl-ShlAssign%3Cu16%3E">ShlAssign<u16></a><a href="#impl-ShlAssign%3C%26%27a%20u8%3E">ShlAssign<&'a u8></a><a href="#impl-ShlAssign%3C%26%27a%20u16%3E">ShlAssign<&'a u16></a><a href="#impl-ShlAssign%3Ci32%3E">ShlAssign<i32></a><a href="#impl-ShlAssign%3C%26%27a%20isize%3E">ShlAssign<&'a isize></a><a href="#impl-ShlAssign%3Ci64%3E">ShlAssign<i64></a><a href="#impl-ShlAssign%3C%26%27a%20usize%3E">ShlAssign<&'a usize></a><a href="#impl-ShlAssign%3Ci8%3E">ShlAssign<i8></a><a href="#impl-ShlAssign%3C%26%27a%20u128%3E">ShlAssign<&'a u128></a><a href="#impl-ShlAssign%3C%26%27a%20i8%3E">ShlAssign<&'a i8></a><a href="#impl-ShlAssign%3Cu32%3E">ShlAssign<u32></a><a href="#impl-ShlAssign%3C%26%27a%20i16%3E">ShlAssign<&'a i16></a><a href="#impl-ShlAssign%3Cisize%3E">ShlAssign<isize></a><a href="#impl-ShlAssign%3Cu64%3E">ShlAssign<u64></a><a href="#impl-ShlAssign%3Cu128%3E">ShlAssign<u128></a><a href="#impl-ShlAssign%3C%26%27a%20i128%3E">ShlAssign<&'a i128></a><a href="#impl-ShlAssign%3C%26%27a%20u32%3E">ShlAssign<&'a u32></a><a href="#impl-ShlAssign%3Ci128%3E">ShlAssign<i128></a><a href="#impl-ShlAssign%3C%26%27a%20u64%3E">ShlAssign<&'a u64></a><a href="#impl-ShlAssign%3C%26%27a%20i64%3E">ShlAssign<&'a i64></a><a href="#impl-BitXorAssign%3C%26%27a%20i32%3E">BitXorAssign<&'a i32></a><a href="#impl-BitXorAssign%3Ci32%3E">BitXorAssign<i32></a><a href="#impl-Div%3C%26%27a%20i32%3E">Div<&'a i32></a><a href="#impl-Div%3Ci32%3E">Div<i32></a><a href="#impl-LowerHex">LowerHex</a><a href="#impl-Sum%3C%26%27a%20i32%3E">Sum<&'a i32></a><a href="#impl-Sum%3Ci32%3E">Sum<i32></a><a href="#impl-BitOrAssign%3C%26%27a%20i32%3E">BitOrAssign<&'a i32></a><a href="#impl-BitOrAssign%3Ci32%3E">BitOrAssign<i32></a><a href="#impl-BitAndAssign%3Ci32%3E">BitAndAssign<i32></a><a href="#impl-BitAndAssign%3C%26%27a%20i32%3E">BitAndAssign<&'a i32></a><a href="#impl-Eq">Eq</a><a href="#impl-Display">Display</a><a href="#impl-PartialEq%3Ci32%3E">PartialEq<i32></a><a href="#impl-Add%3Ci32%3E">Add<i32></a><a href="#impl-Add%3C%26%27a%20i32%3E">Add<&'a i32></a><a href="#impl-BitOr%3C%26%27a%20i32%3E">BitOr<&'a i32></a><a href="#impl-BitOr%3Ci32%3E">BitOr<i32></a><a href="#impl-From%3Ci8%3E">From<i8></a><a href="#impl-From%3Cu8%3E">From<u8></a><a href="#impl-From%3Ci16%3E">From<i16></a><a href="#impl-From%3Cu16%3E">From<u16></a><a href="#impl-RemAssign%3Ci32%3E">RemAssign<i32></a><a href="#impl-RemAssign%3C%26%27a%20i32%3E">RemAssign<&'a i32></a><a href="#impl-DivAssign%3Ci32%3E">DivAssign<i32></a><a href="#impl-DivAssign%3C%26%27a%20i32%3E">DivAssign<&'a i32></a><a href="#impl-MulAssign%3Ci32%3E">MulAssign<i32></a><a href="#impl-MulAssign%3C%26%27a%20i32%3E">MulAssign<&'a i32></a><a href="#impl-SubAssign%3C%26%27a%20i32%3E">SubAssign<&'a i32></a><a href="#impl-SubAssign%3Ci32%3E">SubAssign<i32></a><a href="#impl-AddAssign%3C%26%27a%20i32%3E">AddAssign<&'a i32></a><a href="#impl-AddAssign%3Ci32%3E">AddAssign<i32></a><a href="#impl-Neg">Neg</a><a href="#impl-ShrAssign%3Cu16%3E">ShrAssign<u16></a><a href="#impl-ShrAssign%3Ci16%3E">ShrAssign<i16></a><a href="#impl-ShrAssign%3C%26%27a%20u64%3E">ShrAssign<&'a u64></a><a href="#impl-ShrAssign%3Cu64%3E">ShrAssign<u64></a><a href="#impl-ShrAssign%3C%26%27a%20i32%3E">ShrAssign<&'a i32></a><a href="#impl-ShrAssign%3Cu32%3E">ShrAssign<u32></a><a href="#impl-ShrAssign%3Cu128%3E">ShrAssign<u128></a><a href="#impl-ShrAssign%3C%26%27a%20u8%3E">ShrAssign<&'a u8></a><a href="#impl-ShrAssign%3Cusize%3E">ShrAssign<usize></a><a href="#impl-ShrAssign%3C%26%27a%20isize%3E">ShrAssign<&'a isize></a><a href="#impl-ShrAssign%3C%26%27a%20i8%3E">ShrAssign<&'a i8></a><a href="#impl-ShrAssign%3Cisize%3E">ShrAssign<isize></a><a href="#impl-ShrAssign%3C%26%27a%20i16%3E">ShrAssign<&'a i16></a><a href="#impl-ShrAssign%3C%26%27a%20i64%3E">ShrAssign<&'a i64></a><a href="#impl-ShrAssign%3Ci128%3E">ShrAssign<i128></a><a href="#impl-ShrAssign%3C%26%27a%20u16%3E">ShrAssign<&'a u16></a><a href="#impl-ShrAssign%3Ci32%3E">ShrAssign<i32></a><a href="#impl-ShrAssign%3C%26%27a%20u32%3E">ShrAssign<&'a u32></a><a href="#impl-ShrAssign%3Ci8%3E">ShrAssign<i8></a><a href="#impl-ShrAssign%3Cu8%3E">ShrAssign<u8></a><a href="#impl-ShrAssign%3C%26%27a%20usize%3E">ShrAssign<&'a usize></a><a href="#impl-ShrAssign%3Ci64%3E">ShrAssign<i64></a><a href="#impl-ShrAssign%3C%26%27a%20i128%3E">ShrAssign<&'a i128></a><a href="#impl-ShrAssign%3C%26%27a%20u128%3E">ShrAssign<&'a u128></a><a href="#impl-Termination">Termination</a></div></div><p class='location'><a href='index.html'>std</a></p><script>window.sidebarCurrent = {name: 'i32', ty: 'primitive', relpath: ''};</script><script defer src="sidebar-items.js"></script></div>
</nav>
<div class="theme-picker">
<button id="theme-picker" aria-label="Pick another theme!">
<img src="../brush.svg" width="18" alt="Pick another theme!">
</button>
<div id="theme-choices"></div>
</div>
<script src="../theme.js"></script>
<nav class="sub">
<form class="search-form js-only">
<div class="search-container">
<input class="search-input" name="search"
autocomplete="off"
placeholder="Click or press ‘S’ to search, ‘?’ for more options…"
type="search">
</div>
</form>
</nav>
<section id='main' class="content">
<h1 class='fqn'><span class='in-band'>Primitive Type <a class="primitive" href=''>i32</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 32-bit signed integer type.</p>
<p><em><a href="i32/index.html">See also the <code>std::i32</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>i16</code> in there.</p>
</div>
<h2 id='methods' class='small-section-header'>
Methods<a href='#methods' class='anchor'></a>
</h2>
<h3 id='impl' class='impl'><span class='in-band'><code>impl <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#1220-1222' 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>pub const fn <a href='#method.min_value' class='fnname'>min_value</a>() -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#113-115' title='goto source code'>[src]</a></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>
<p>Basic usage:</p>
<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=%23!%5Ballow(unused)%5D%0Afn%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>pub const fn <a href='#method.max_value' class='fnname'>max_value</a>() -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#128-130' title='goto source code'>[src]</a></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>
<p>Basic usage:</p>
<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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.ParseIntError.html" title="struct std::num::ParseIntError">ParseIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#155-157' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Converts a string slice in a given base to an integer.</p>
<p>The string is expected to be an optional <code>+</code> or <code>-</code> sign
followed by digits.
Leading and trailing whitespace represent an error.
Digits are a subset of these characters, depending on <code>radix</code>:</p>
<ul>
<li><code>0-9</code></li>
<li><code>a-z</code></li>
<li><code>A-Z</code></li>
</ul>
<h1 id="panics" class="section-header"><a href="#panics">Panics</a></h1>
<p>This function panics if <code>radix</code> is not in the range from 2 to 36.</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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.count_ones' class='fnname'>count_ones</a>(self) -> <a class="primitive" href="primitive.u32.html">u32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#172' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.count_zeros' class='fnname'>count_zeros</a>(self) -> <a class="primitive" href="primitive.u32.html">u32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#187-189' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.leading_zeros' class='fnname'>leading_zeros</a>(self) -> <a class="primitive" href="primitive.u32.html">u32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#205-207' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.trailing_zeros' class='fnname'>trailing_zeros</a>(self) -> <a class="primitive" href="primitive.u32.html">u32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#223-225' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#244-246' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#266-268' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.swap_bytes' class='fnname'>swap_bytes</a>(self) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#287-289' title='goto source code'>[src]</a></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="ident">i16</span> <span class="op">=</span> <span class="number">0b0000000_01010101</span>;
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">n</span>, <span class="number">85</span>);
<span class="kw">let</span> <span class="ident">m</span> <span class="op">=</span> <span class="ident">n</span>.<span class="ident">swap_bytes</span>();
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>, <span class="number">0b01010101_00000000</span>);
<span class="macro">assert_eq</span><span class="macro">!</span>(<span class="ident">m</span>, <span class="number">21760</span>);<a class="test-arrow" target="_blank" href="https://play.rust-lang.org/?code=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Alet%20n%3A%20i16%20%3D%200b0000000_01010101%3B%0Aassert_eq!(n%2C%2085)%3B%0A%0Alet%20m%20%3D%20n.swap_bytes()%3B%0A%0Aassert_eq!(m%2C%200b01010101_00000000)%3B%0Aassert_eq!(m%2C%2021760)%3B%0A%7D">Run</a></pre>
</div><h4 id='method.from_be' class="method"><span id='from_be.v' class='invisible'><code>pub fn <a href='#method.from_be' class='fnname'>from_be</a>(x: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#311-313' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.from_le' class='fnname'>from_le</a>(x: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#335-337' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.to_be' class='fnname'>to_be</a>(self) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#359-361' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.to_le' class='fnname'>to_le</a>(self) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#383-385' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.checked_add' class='fnname'>checked_add</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#400-403' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Checked integer addition. Computes <code>self + rhs</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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.checked_sub' class='fnname'>checked_sub</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#418-421' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Checked integer subtraction. Computes <code>self - rhs</code>, returning
<code>None</code> if overflow 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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.checked_mul' class='fnname'>checked_mul</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#436-439' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Checked integer multiplication. Computes <code>self * rhs</code>, returning
<code>None</code> if 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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.checked_div' class='fnname'>checked_div</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#455-461' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Checked integer division. Computes <code>self / rhs</code>, returning <code>None</code>
if <code>rhs == 0</code> or the division results in 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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.checked_rem' class='fnname'>checked_rem</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#479-485' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Checked integer remainder. Computes <code>self % rhs</code>, returning <code>None</code>
if <code>rhs == 0</code> or the division results in 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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#502-505' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#520-523' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#538-541' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.13.0'>1.13.0</div><a class='srclink' href='../src/core/num/mod.rs.html#558-564' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.saturating_add' class='fnname'>saturating_add</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#579-585' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Saturating integer addition. Computes <code>self + rhs</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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.saturating_sub' class='fnname'>saturating_sub</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#600-606' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Saturating integer subtraction. Computes <code>self - rhs</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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.saturating_mul' class='fnname'>saturating_mul</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#624-632' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Saturating integer multiplication. Computes <code>self * rhs</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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.wrapping_add' class='fnname'>wrapping_add</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#647-651' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Wrapping (modular) addition. Computes <code>self + rhs</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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.wrapping_sub' class='fnname'>wrapping_sub</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#666-670' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Wrapping (modular) subtraction. Computes <code>self - rhs</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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.wrapping_mul' class='fnname'>wrapping_mul</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#685-689' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Wrapping (modular) multiplication. Computes <code>self * rhs</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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.wrapping_div' class='fnname'>wrapping_div</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div><a class='srclink' href='../src/core/num/mod.rs.html#715-717' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Wrapping (modular) division. Computes <code>self / rhs</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-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-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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.wrapping_rem' class='fnname'>wrapping_rem</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div><a class='srclink' href='../src/core/num/mod.rs.html#741-743' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Wrapping (modular) remainder. Computes <code>self % rhs</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-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-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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.wrapping_neg' class='fnname'>wrapping_neg</a>(self) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div><a class='srclink' href='../src/core/num/mod.rs.html#764-766' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div><a class='srclink' href='../src/core/num/mod.rs.html#789-793' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.2.0'>1.2.0</div><a class='srclink' href='../src/core/num/mod.rs.html#816-820' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.wrapping_abs' class='fnname'>wrapping_abs</a>(self) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.13.0'>1.13.0</div><a class='srclink' href='../src/core/num/mod.rs.html#842-848' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.overflowing_add' class='fnname'>overflowing_add</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#868-874' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.overflowing_sub' class='fnname'>overflowing_sub</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#894-900' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.overflowing_mul' class='fnname'>overflowing_mul</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#918-924' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.overflowing_div' class='fnname'>overflowing_div</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#948-954' title='goto source code'>[src]</a></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-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-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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.overflowing_rem' class='fnname'>overflowing_rem</a>(self, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.tuple.html">(</a><a class="primitive" href="primitive.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#978-984' title='goto source code'>[src]</a></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-4" class="section-header"><a href="#panics-4">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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#1006-1012' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#1032-1034' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.7.0'>1.7.0</div><a class='srclink' href='../src/core/num/mod.rs.html#1054-1056' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a>, <a class="primitive" href="primitive.bool.html">bool</a><a class="primitive" href="primitive.tuple.html">)</a></code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.13.0'>1.13.0</div><a class='srclink' href='../src/core/num/mod.rs.html#1077-1083' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub 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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#1099-1119' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.abs' class='fnname'>abs</a>(self) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#1141-1150' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.signum' class='fnname'>signum</a>(self) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#1169-1175' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.is_positive' class='fnname'>is_positive</a>(self) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#1190' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%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>pub fn <a href='#method.is_negative' class='fnname'>is_negative</a>(self) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#1205' title='goto source code'>[src]</a></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=%23!%5Ballow(unused)%5D%0Afn%20main()%20%7B%0Aassert!((-10i8).is_negative())%3B%0Aassert!(!10i8.is_negative())%3B%0A%7D">Run</a></pre>
</div></div>
<h2 id='implementations' class='small-section-header'>
Trait Implementations<a href='#implementations' class='anchor'></a>
</h2>
<h3 id='impl-Binary' 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.i32.html">i32</a></code><a href='#impl-Binary' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#148-152' 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.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.unit.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#149-151' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 id='impl-FromStr' 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.i32.html">i32</a></code><a href='#impl-FromStr' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2960-2965' 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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.ParseIntError.html" title="struct std::num::ParseIntError">ParseIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#2962-2964' title='goto source code'>[src]</a></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 id='impl-Sub%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Sub%3C%26%27a%20i32%3E' class='anchor'></a></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' 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.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Sub.html#associatedtype.Output" title="type std::ops::Sub::Output">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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Sub.html#associatedtype.Output" title="type std::ops::Sub::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>-</code> operation.</p>
</div></div><h3 id='impl-Sub%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Sub%3C%26%27a%20i32%3E-1' class='anchor'></a></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-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.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Sub.html#associatedtype.Output" title="type std::ops::Sub::Output">Output</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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Sub.html#associatedtype.Output" title="type std::ops::Sub::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>-</code> operation.</p>
</div></div><h3 id='impl-Sub%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Sub%3Ci32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#199-205' 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.i32.html">i32</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 class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#204' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>-</code> operation.</p>
</div></div><h3 id='impl-Sub%3Ci32%3E-1' 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.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Sub%3Ci32%3E-1' class='anchor'></a></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-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.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Sub.html#associatedtype.Output" title="type std::ops::Sub::Output">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 class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Sub.html" title="trait std::ops::Sub">Sub</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Sub.html#associatedtype.Output" title="type std::ops::Sub::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>-</code> operation.</p>
</div></div><h3 id='impl-Shr%3Cisize%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cisize%3E' class='anchor'></a></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-4' class="type"><span id='Output.t-4' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu8%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu8%3E' class='anchor'></a></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-5' class="type"><span id='Output.t-5' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu16%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu16%3E' class='anchor'></a></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.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i16%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i16%3E' class='anchor'></a></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-7' class="type"><span id='Output.t-7' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</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 <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci64%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci64%3E' class='anchor'></a></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-8' class="type"><span id='Output.t-8' class='invisible'><code>type <a href='../std/ops/trait.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u64%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u64%3E' class='anchor'></a></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.Shr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu64%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu64%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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 class="primitive" href="primitive.u64.html">u64</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i128%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i128%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i8%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i8%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</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 <a class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u8%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u8%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i128%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i128%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</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 <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i32%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i32%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i8%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i8%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u8%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u8%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i32%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci16%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci16%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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 class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u16%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u16%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 <a class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci8%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci8%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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 class="primitive" href="primitive.i8.html">i8</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u128%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u128%3E' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci128%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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.i128.html">i128</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci64%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci64%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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.i64.html">i64</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i16%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i16%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu32%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu32%3E' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci32%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u64%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u64%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</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 <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu128%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu128%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci8%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci8%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci128%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci128%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20isize%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20isize%3E' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u128%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u128%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</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 <a class="primitive" href="primitive.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu16%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu16%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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.u16.html">u16</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu128%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu128%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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.u128.html">u128</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u16%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u16%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i64%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i64%3E' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u32%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u32%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 <a class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu32%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu32%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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.u32.html">u32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu64%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu64%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cisize%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cisize%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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 class="primitive" href="primitive.isize.html">isize</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20usize%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20usize%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cusize%3E' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cusize%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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.usize.html">usize</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20u32%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20u32%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cusize%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cusize%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20usize%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20usize%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20isize%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20isize%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</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 <a class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci32%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci32%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Ci16%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Ci16%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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 class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3Cu8%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3Cu8%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#488-496' 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.i32.html">i32</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 class="primitive" href="primitive.u8.html">u8</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#493-495' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Shr%3C%26%27a%20i64%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shr%3C%26%27a%20i64%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">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.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shr.html#associatedtype.Output" title="type std::ops::Shr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>></code> operation.</p>
</div></div><h3 id='impl-Debug' 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.i32.html">i32</a></code><a href='#impl-Debug' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#159-164' 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.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.unit.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#161-163' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Formats the value using the given formatter. <a href="../std/fmt/trait.Debug.html#tymethod.fmt">Read more</a></p>
</div></div><h3 id='impl-BitXor%3Ci32%3E' 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.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitXor%3Ci32%3E' class='anchor'></a></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.BitXor.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitXor.html#associatedtype.Output" title="type std::ops::BitXor::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitXor.html#associatedtype.Output" title="type std::ops::BitXor::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>^</code> operation.</p>
</div></div><h3 id='impl-BitXor%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitXor%3C%26%27a%20i32%3E' class='anchor'></a></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-53' class="type"><span id='Output.t-53' class='invisible'><code>type <a href='../std/ops/trait.BitXor.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitXor.html#associatedtype.Output" title="type std::ops::BitXor::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitXor.html#associatedtype.Output" title="type std::ops::BitXor::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>^</code> operation.</p>
</div></div><h3 id='impl-BitXor%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitXor%3C%26%27a%20i32%3E-1' class='anchor'></a></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-54' class="type"><span id='Output.t-54' class='invisible'><code>type <a href='../std/ops/trait.BitXor.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitXor.html#associatedtype.Output" title="type std::ops::BitXor::Output">Output</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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitXor.html" title="trait std::ops::BitXor">BitXor</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitXor.html#associatedtype.Output" title="type std::ops::BitXor::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>^</code> operation.</p>
</div></div><h3 id='impl-BitXor%3Ci32%3E-1' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitXor%3Ci32%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#305-310' 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.BitXor.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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 class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#309' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>^</code> operation.</p>
</div></div><h3 id='impl-Not' 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.i32.html">i32</a></code><a href='#impl-Not' class='anchor'></a></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-56' class="type"><span id='Output.t-56' class='invisible'><code>type <a href='../std/ops/trait.Not.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Not.html" title="trait std::ops::Not">Not</a>>::<a class="type" href="../std/ops/trait.Not.html#associatedtype.Output" title="type std::ops::Not::Output">Output</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.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Not.html" title="trait std::ops::Not">Not</a>>::<a class="type" href="../std/ops/trait.Not.html#associatedtype.Output" title="type std::ops::Not::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#25-27' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the unary <code>!</code> operation.</p>
</div></div><h3 id='impl-Not-1' 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.i32.html">i32</a></code><a href='#impl-Not-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#56-61' 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.Not.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#60' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the unary <code>!</code> operation.</p>
</div></div><h3 id='impl-Rem%3Ci32%3E' 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.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Rem%3Ci32%3E' class='anchor'></a></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-58' class="type"><span id='Output.t-58' class='invisible'><code>type <a href='../std/ops/trait.Rem.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Rem.html#associatedtype.Output" title="type std::ops::Rem::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Rem.html#associatedtype.Output" title="type std::ops::Rem::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>%</code> operation.</p>
</div></div><h3 id='impl-Rem%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Rem%3C%26%27a%20i32%3E' class='anchor'></a></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-59' class="type"><span id='Output.t-59' class='invisible'><code>type <a href='../std/ops/trait.Rem.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Rem.html#associatedtype.Output" title="type std::ops::Rem::Output">Output</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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Rem.html#associatedtype.Output" title="type std::ops::Rem::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>%</code> operation.</p>
</div></div><h3 id='impl-Rem%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Rem%3C%26%27a%20i32%3E-1' class='anchor'></a></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-60' class="type"><span id='Output.t-60' class='invisible'><code>type <a href='../std/ops/trait.Rem.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Rem.html#associatedtype.Output" title="type std::ops::Rem::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Rem.html" title="trait std::ops::Rem">Rem</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Rem.html#associatedtype.Output" title="type std::ops::Rem::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>%</code> operation.</p>
</div></div><h3 id='impl-Rem%3Ci32%3E-1' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Rem%3Ci32%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#524-529' 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-61' class="type"><span id='Output.t-61' class='invisible'><code>type <a href='../std/ops/trait.Rem.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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 class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#528' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>%</code> operation.</p>
</div></div><h3 id='impl-Product%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Product%3C%26%27a%20i32%3E' class='anchor'></a></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#796-800' 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.i32.html">i32</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.i32.html">i32</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/traits.rs.html#797-799' title='goto source code'>[src]</a></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 id='impl-Product%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Product%3Ci32%3E' class='anchor'></a></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#782-786' 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.i32.html">i32</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.i32.html">i32</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/traits.rs.html#783-785' title='goto source code'>[src]</a></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 id='impl-UpperHex' 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.i32.html">i32</a></code><a href='#impl-UpperHex' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#148-152' 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.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.unit.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#149-151' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 id='impl-Step' 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.i32.html">i32</a></code><a href='#impl-Step' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/range.rs.html#109-143' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><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.i32.html">i32</a>, end: &<a class="primitive" href="primitive.i32.html">i32</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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/range.rs.html#112-121' title='goto source code'>[src]</a></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.add_usize' class="method"><span id='add_usize.v' class='invisible'><code>fn <a href='../std/iter/trait.Step.html#tymethod.add_usize' class='fnname'>add_usize</a>(&self, n: <a class="primitive" href="primitive.usize.html">usize</a>) -> <a class="enum" href="../std/option/enum.Option.html" title="enum std::option::Option">Option</a><<a class="primitive" href="primitive.i32.html">i32</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/range.rs.html#125-140' title='goto source code'>[src]</a></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>Add an usize, returning None on overflow</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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/range.rs.html#53-55' title='goto source code'>[src]</a></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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/range.rs.html#58-60' title='goto source code'>[src]</a></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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/range.rs.html#63-65' title='goto source code'>[src]</a></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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/range.rs.html#68-70' title='goto source code'>[src]</a></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></div><h3 id='impl-Mul%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Mul%3Ci32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#317-323' 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.Mul.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#322' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>*</code> operation.</p>
</div></div><h3 id='impl-Mul%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Mul%3C%26%27a%20i32%3E' class='anchor'></a></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.Mul.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Mul.html#associatedtype.Output" title="type std::ops::Mul::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Mul.html#associatedtype.Output" title="type std::ops::Mul::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>*</code> operation.</p>
</div></div><h3 id='impl-Mul%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Mul%3C%26%27a%20i32%3E-1' class='anchor'></a></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-64' class="type"><span id='Output.t-64' class='invisible'><code>type <a href='../std/ops/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Mul.html#associatedtype.Output" title="type std::ops::Mul::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Mul.html#associatedtype.Output" title="type std::ops::Mul::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>*</code> operation.</p>
</div></div><h3 id='impl-Mul%3Ci32%3E-1' 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.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Mul%3Ci32%3E-1' class='anchor'></a></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-65' class="type"><span id='Output.t-65' class='invisible'><code>type <a href='../std/ops/trait.Mul.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Mul.html#associatedtype.Output" title="type std::ops::Mul::Output">Output</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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Mul.html" title="trait std::ops::Mul">Mul</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Mul.html#associatedtype.Output" title="type std::ops::Mul::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>*</code> operation.</p>
</div></div><h3 id='impl-Octal' 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.i32.html">i32</a></code><a href='#impl-Octal' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#148-152' 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.unit.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#149-151' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 id='impl-Shl%3Cusize%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cusize%3E' class='anchor'></a></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-66' class="type"><span id='Output.t-66' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cisize%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cisize%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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.isize.html">isize</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u128%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u128%3E' class='anchor'></a></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-68' class="type"><span id='Output.t-68' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20isize%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20isize%3E' class='anchor'></a></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-69' class="type"><span id='Output.t-69' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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 <a class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20usize%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20usize%3E' class='anchor'></a></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-70' class="type"><span id='Output.t-70' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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 <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u32%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u32%3E' class='anchor'></a></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-71' class="type"><span id='Output.t-71' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 <a class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci64%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci64%3E' class='anchor'></a></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-72' class="type"><span id='Output.t-72' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u64%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u64%3E' class='anchor'></a></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-73' class="type"><span id='Output.t-73' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i32%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i32%3E' class='anchor'></a></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-74' class="type"><span id='Output.t-74' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci32%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci32%3E' class='anchor'></a></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-75' class="type"><span id='Output.t-75' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci64%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci64%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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.i64.html">i64</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i64%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i64%3E' class='anchor'></a></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-77' class="type"><span id='Output.t-77' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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 <a class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci128%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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.i128.html">i128</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu128%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.Shl.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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 class="primitive" href="primitive.u128.html">u128</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i16%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i16%3E' class='anchor'></a></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-80' class="type"><span id='Output.t-80' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu16%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu16%3E' class='anchor'></a></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-81' class="type"><span id='Output.t-81' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 class="primitive" href="primitive.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci16%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci16%3E' class='anchor'></a></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-82' class="type"><span id='Output.t-82' class='invisible'><code>type <a href='../std/ops/trait.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i16%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i16%3E-1' class='anchor'></a></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.Shl.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 <a class="primitive" href="primitive.i16.html">i16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cisize%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cisize%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 class="primitive" href="primitive.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i8%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i8%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u64%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u64%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 <a class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i32%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i128%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i128%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu8%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu8%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.i32.html">i32</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.u8.html">u8</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci8%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci8%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.i32.html">i32</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 class="primitive" href="primitive.i8.html">i8</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu16%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu16%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.i32.html">i32</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 class="primitive" href="primitive.u16.html">u16</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u128%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u128%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci16%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci16%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.i32.html">i32</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 class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u16%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u16%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu128%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu128%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.u128.html">u128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu32%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu32%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 class="primitive" href="primitive.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci128%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci128%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci8%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci8%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu64%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu64%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.i32.html">i32</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 class="primitive" href="primitive.u64.html">u64</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i128%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i128%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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 <a class="primitive" href="primitive.i128.html">i128</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20isize%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20isize%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.isize.html">isize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i64%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i64%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 <a class="primitive" href="primitive.i64.html">i64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu64%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu64%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 class="primitive" href="primitive.u64.html">u64</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20usize%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20usize%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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 <a class="primitive" href="primitive.usize.html">usize</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u16%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u16%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.u16.html">u16</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Ci32%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Ci32%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.i32.html">i32</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 class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u8%3E' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u8%3E' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cusize%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cusize%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.i32.html">i32</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.usize.html">usize</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu32%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu32%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#386-394' 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.i32.html">i32</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 class="primitive" href="primitive.u32.html">u32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#391-393' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u32%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u32%3E-1' class='anchor'></a></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-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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.u32.html">u32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20u8%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20u8%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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 <a class="primitive" href="primitive.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3C%26%27a%20i8%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3C%26%27a%20i8%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</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 <a class="primitive" href="primitive.i8.html">i8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-Shl%3Cu8%3E-1' 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.i32.html">i32</a></code><a href='#impl-Shl%3Cu8%3E-1' class='anchor'></a></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.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">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.u8.html">u8</a>) -> <<a class="primitive" href="primitive.i32.html">i32</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="type" href="../std/ops/trait.Shl.html#associatedtype.Output" title="type std::ops::Shl::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<</code> operation.</p>
</div></div><h3 id='impl-TryFrom%3Ci128%3E' 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.i32.html">i32</a></code><a href='#impl-TryFrom%3Ci128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3058-3071' 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.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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3062-3070' title='goto source code'>[src]</a></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 id='impl-TryFrom%3Cisize%3E' 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.i32.html">i32</a></code><a href='#impl-TryFrom%3Cisize%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3058-3071' 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.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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3062-3070' title='goto source code'>[src]</a></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 id='impl-TryFrom%3Cu128%3E' 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.i32.html">i32</a></code><a href='#impl-TryFrom%3Cu128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3039-3050' 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.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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3043-3049' title='goto source code'>[src]</a></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 id='impl-TryFrom%3Ci64%3E' 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.i32.html">i32</a></code><a href='#impl-TryFrom%3Ci64%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3058-3071' 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.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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3062-3070' title='goto source code'>[src]</a></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 id='impl-TryFrom%3Cu32%3E' 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.i32.html">i32</a></code><a href='#impl-TryFrom%3Cu32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3039-3050' 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.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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3043-3049' title='goto source code'>[src]</a></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 id='impl-TryFrom%3Cu64%3E' 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.i32.html">i32</a></code><a href='#impl-TryFrom%3Cu64%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3039-3050' 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.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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3043-3049' title='goto source code'>[src]</a></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 id='impl-TryFrom%3Cusize%3E' 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.i32.html">i32</a></code><a href='#impl-TryFrom%3Cusize%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3039-3050' 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.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.i32.html">i32</a>, <a class="struct" href="../std/num/struct.TryFromIntError.html" title="struct std::num::TryFromIntError">TryFromIntError</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3043-3049' title='goto source code'>[src]</a></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 id='impl-Zeroable' 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.i32.html">i32</a></code><a href='#impl-Zeroable' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/nonzero.rs.html#41-46' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.is_zero' class="method"><span id='is_zero.v' class='invisible'><code>fn <a href='../core/nonzero/trait.Zeroable.html#tymethod.is_zero' class='fnname'>is_zero</a>(&self) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/nonzero.rs.html#43-45' title='goto source code'>[src]</a></span></h4>
<div class='stability'><div class='stab unstable'><details><summary><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>nonzero </code><a href="https://github.com/rust-lang/rust/issues/27730">#27730</a>)</summary><p>needs an RFC to flesh out the design</p>
</details></div></div><div class='docblock'><p>Whether this value is zero</p>
</div></div><h3 id='impl-BitAnd%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitAnd%3C%26%27a%20i32%3E' class='anchor'></a></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.BitAnd.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitAnd.html#associatedtype.Output" title="type std::ops::BitAnd::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitAnd.html#associatedtype.Output" title="type std::ops::BitAnd::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>&</code> operation.</p>
</div></div><h3 id='impl-BitAnd%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitAnd%3Ci32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#138-143' 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.BitAnd.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#142' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>&</code> operation.</p>
</div></div><h3 id='impl-BitAnd%3Ci32%3E-1' 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.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitAnd%3Ci32%3E-1' class='anchor'></a></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-116' class="type"><span id='Output.t-116' class='invisible'><code>type <a href='../std/ops/trait.BitAnd.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitAnd.html#associatedtype.Output" title="type std::ops::BitAnd::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitAnd.html#associatedtype.Output" title="type std::ops::BitAnd::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>&</code> operation.</p>
</div></div><h3 id='impl-BitAnd%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitAnd%3C%26%27a%20i32%3E-1' class='anchor'></a></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.BitAnd.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitAnd.html#associatedtype.Output" title="type std::ops::BitAnd::Output">Output</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, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitAnd.html" title="trait std::ops::BitAnd">BitAnd</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitAnd.html#associatedtype.Output" title="type std::ops::BitAnd::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>&</code> operation.</p>
</div></div><h3 id='impl-Hash' 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.i32.html">i32</a></code><a href='#impl-Hash' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/hash/mod.rs.html#554-564' 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: <a class="primitive" href="primitive.reference.html">&mut </a>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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/hash/mod.rs.html#555-557' title='goto source code'>[src]</a></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.i32.html">i32</a><a class="primitive" href="primitive.slice.html">]</a>, state: <a class="primitive" href="primitive.reference.html">&mut </a>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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/hash/mod.rs.html#559-563' title='goto source code'>[src]</a></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 id='impl-Default' 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.i32.html">i32</a></code><a href='#impl-Default' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/default.rs.html#131-135' 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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/default.rs.html#134' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Returns the default value of <code>0</code></p>
</div></div><h3 id='impl-PartialOrd%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-PartialOrd%3Ci32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#840-853' 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.i32.html">i32</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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#842-844' title='goto source code'>[src]</a></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.i32.html">i32</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#846' title='goto source code'>[src]</a></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.i32.html">i32</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#848' title='goto source code'>[src]</a></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.i32.html">i32</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#850' title='goto source code'>[src]</a></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.i32.html">i32</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#852' title='goto source code'>[src]</a></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 id='impl-Ord' 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.i32.html">i32</a></code><a href='#impl-Ord' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#856-863' 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.i32.html">i32</a>) -> <a class="enum" href="../std/cmp/enum.Ordering.html" title="enum std::cmp::Ordering">Ordering</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#858-862' title='goto source code'>[src]</a></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><h4 id='method.max' class="method"><span id='max.v' class='invisible'><code>fn <a href='../std/cmp/trait.Ord.html#method.max' class='fnname'>max</a>(self, other: Self) -> Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../src/core/cmp.rs.html#460-463' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Compares and returns the maximum of two values. <a href="../std/cmp/trait.Ord.html#method.max">Read more</a></p>
</div><h4 id='method.min' class="method"><span id='min.v' class='invisible'><code>fn <a href='../std/cmp/trait.Ord.html#method.min' class='fnname'>min</a>(self, other: Self) -> Self</code></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.21.0'>1.21.0</div><a class='srclink' href='../src/core/cmp.rs.html#476-479' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Compares and returns the minimum of two values. <a href="../std/cmp/trait.Ord.html#method.min">Read more</a></p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Cu8%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Cu8%3E' class='anchor'></a></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/bit.rs.html#740-746' 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.u8.html">u8</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Ci16%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Ci16%3E' class='anchor'></a></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/bit.rs.html#740-746' 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.i16.html">i16</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Cusize%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Cusize%3E' class='anchor'></a></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/bit.rs.html#740-746' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Cu16%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Cu16%3E' class='anchor'></a></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/bit.rs.html#740-746' 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.u16.html">u16</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20u8%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20u8%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.u8.html">u8</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20u16%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20u16%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.u16.html">u16</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Ci32%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Ci32%3E' class='anchor'></a></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/bit.rs.html#740-746' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20isize%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20isize%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.isize.html">isize</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Ci64%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Ci64%3E' class='anchor'></a></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/bit.rs.html#740-746' 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.i64.html">i64</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20usize%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20usize%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.usize.html">usize</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Ci8%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Ci8%3E' class='anchor'></a></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/bit.rs.html#740-746' 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.i8.html">i8</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20u128%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20u128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-12' class="method"><span id='shl_assign.v-12' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.u128.html">u128</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20i8%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20i8%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-13' class="method"><span id='shl_assign.v-13' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i8.html">i8</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Cu32%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Cu32%3E' class='anchor'></a></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/bit.rs.html#740-746' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-14' class="method"><span id='shl_assign.v-14' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20i16%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20i16%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-15' class="method"><span id='shl_assign.v-15' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: &'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#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Cisize%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Cisize%3E' class='anchor'></a></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/bit.rs.html#740-746' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-16' class="method"><span id='shl_assign.v-16' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Cu64%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Cu64%3E' class='anchor'></a></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/bit.rs.html#740-746' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-17' class="method"><span id='shl_assign.v-17' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Cu128%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Cu128%3E' class='anchor'></a></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/bit.rs.html#740-746' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-18' class="method"><span id='shl_assign.v-18' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20i128%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20i128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-19' class="method"><span id='shl_assign.v-19' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i128.html">i128</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20u32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20u32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-20' class="method"><span id='shl_assign.v-20' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.u32.html">u32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3Ci128%3E' 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.i32.html">i32</a></code><a href='#impl-ShlAssign%3Ci128%3E' class='anchor'></a></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/bit.rs.html#740-746' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-21' class="method"><span id='shl_assign.v-21' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#743-745' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20u64%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20u64%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-22' class="method"><span id='shl_assign.v-22' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.u64.html">u64</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-ShlAssign%3C%26%27a%20i64%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShlAssign.html" title="trait std::ops::ShlAssign">ShlAssign</a><&'a <a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShlAssign%3C%26%27a%20i64%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shl_assign-23' class="method"><span id='shl_assign.v-23' class='invisible'><code>fn <a href='../std/ops/trait.ShlAssign.html#tymethod.shl_assign' class='fnname'>shl_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i64.html">i64</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code><<=</code> operation.</p>
</div></div><h3 id='impl-BitXorAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitXorAssign.html" title="trait std::ops::BitXorAssign">BitXorAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitXorAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>^=</code> operation.</p>
</div></div><h3 id='impl-BitXorAssign%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitXorAssign%3Ci32%3E' class='anchor'></a></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/bit.rs.html#694-697' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.bitxor_assign-1' class="method"><span id='bitxor_assign.v-1' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#696' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>^=</code> operation.</p>
</div></div><h3 id='impl-Div%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Div%3C%26%27a%20i32%3E' class='anchor'></a></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-118' class="type"><span id='Output.t-118' class='invisible'><code>type <a href='../std/ops/trait.Div.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Div.html#associatedtype.Output" title="type std::ops::Div::Output">Output</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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Div.html#associatedtype.Output" title="type std::ops::Div::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>/</code> operation.</p>
</div></div><h3 id='impl-Div%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Div%3Ci32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#441-446' 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-119' class="type"><span id='Output.t-119' class='invisible'><code>type <a href='../std/ops/trait.Div.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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 class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#445' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>/</code> operation.</p>
</div></div><h3 id='impl-Div%3Ci32%3E-1' 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.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Div%3Ci32%3E-1' class='anchor'></a></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.Div.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Div.html#associatedtype.Output" title="type std::ops::Div::Output">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 class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Div.html#associatedtype.Output" title="type std::ops::Div::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>/</code> operation.</p>
</div></div><h3 id='impl-Div%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Div%3C%26%27a%20i32%3E-1' class='anchor'></a></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-121' class="type"><span id='Output.t-121' class='invisible'><code>type <a href='../std/ops/trait.Div.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Div.html#associatedtype.Output" title="type std::ops::Div::Output">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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Div.html" title="trait std::ops::Div">Div</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Div.html#associatedtype.Output" title="type std::ops::Div::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>/</code> operation.</p>
</div></div><h3 id='impl-LowerHex' 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.i32.html">i32</a></code><a href='#impl-LowerHex' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#148-152' 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.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.unit.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#149-151' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Formats the value using the given formatter.</p>
</div></div><h3 id='impl-Sum%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Sum%3C%26%27a%20i32%3E' class='anchor'></a></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#789-793' 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.i32.html">i32</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.i32.html">i32</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/traits.rs.html#790-792' title='goto source code'>[src]</a></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 id='impl-Sum%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Sum%3Ci32%3E' class='anchor'></a></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#775-779' 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.i32.html">i32</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.i32.html">i32</a>>, </span></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/iter/traits.rs.html#776-778' title='goto source code'>[src]</a></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 id='impl-BitOrAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitOrAssign.html" title="trait std::ops::BitOrAssign">BitOrAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitOrAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>|=</code> operation.</p>
</div></div><h3 id='impl-BitOrAssign%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitOrAssign%3Ci32%3E' class='anchor'></a></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/bit.rs.html#646-649' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.bitor_assign-1' class="method"><span id='bitor_assign.v-1' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#648' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>|=</code> operation.</p>
</div></div><h3 id='impl-BitAndAssign%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitAndAssign%3Ci32%3E' class='anchor'></a></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/bit.rs.html#598-601' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#600' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>&=</code> operation.</p>
</div></div><h3 id='impl-BitAndAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.BitAndAssign.html" title="trait std::ops::BitAndAssign">BitAndAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitAndAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.bitand_assign-1' class="method"><span id='bitand_assign.v-1' class='invisible'><code>fn <a href='../std/ops/trait.BitAndAssign.html#tymethod.bitand_assign' class='fnname'>bitand_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>&=</code> operation.</p>
</div></div><h3 id='impl-Eq' 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.i32.html">i32</a></code><a href='#impl-Eq' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#788' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'></div><h3 id='impl-Display' 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.i32.html">i32</a></code><a href='#impl-Display' class='anchor'></a></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-5' class="method"><span id='fmt.v-5' 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.unit.html">()</a>, <a class="struct" href="../std/fmt/struct.Error.html" title="struct std::fmt::Error">Error</a>></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/fmt/num.rs.html#202-258' title='goto source code'>[src]</a></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 id='impl-PartialEq%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-PartialEq%3Ci32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#764-769' 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.i32.html">i32</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#766' title='goto source code'>[src]</a></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.i32.html">i32</a>) -> <a class="primitive" href="primitive.bool.html">bool</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/cmp.rs.html#768' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>This method tests for <code>!=</code>.</p>
</div></div><h3 id='impl-Add%3Ci32%3E' 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.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Add%3Ci32%3E' class='anchor'></a></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-122' class="type"><span id='Output.t-122' class='invisible'><code>type <a href='../std/ops/trait.Add.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Add.html#associatedtype.Output" title="type std::ops::Add::Output">Output</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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Add.html#associatedtype.Output" title="type std::ops::Add::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>+</code> operation.</p>
</div></div><h3 id='impl-Add%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Add%3C%26%27a%20i32%3E' class='anchor'></a></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-123' class="type"><span id='Output.t-123' class='invisible'><code>type <a href='../std/ops/trait.Add.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Add.html#associatedtype.Output" title="type std::ops::Add::Output">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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Add.html#associatedtype.Output" title="type std::ops::Add::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>+</code> operation.</p>
</div></div><h3 id='impl-Add%3Ci32%3E-1' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Add%3Ci32%3E-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#103-109' 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.Add.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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 class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#108' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>+</code> operation.</p>
</div></div><h3 id='impl-Add%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Add%3C%26%27a%20i32%3E-1' class='anchor'></a></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-125' class="type"><span id='Output.t-125' class='invisible'><code>type <a href='../std/ops/trait.Add.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Add.html#associatedtype.Output" title="type std::ops::Add::Output">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.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Add.html" title="trait std::ops::Add">Add</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.Add.html#associatedtype.Output" title="type std::ops::Add::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>+</code> operation.</p>
</div></div><h3 id='impl-BitOr%3C%26%27a%20i32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitOr%3C%26%27a%20i32%3E' class='anchor'></a></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-126' class="type"><span id='Output.t-126' class='invisible'><code>type <a href='../std/ops/trait.BitOr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitOr.html#associatedtype.Output" title="type std::ops::BitOr::Output">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 <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitOr.html#associatedtype.Output" title="type std::ops::BitOr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#55-57' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>|</code> operation.</p>
</div></div><h3 id='impl-BitOr%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitOr%3Ci32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#220-225' 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.BitOr.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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, rhs: <a class="primitive" href="primitive.i32.html">i32</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#224' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>|</code> operation.</p>
</div></div><h3 id='impl-BitOr%3C%26%27a%20i32%3E-1' 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.i32.html">i32</a>> for &'b <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitOr%3C%26%27a%20i32%3E-1' class='anchor'></a></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.BitOr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitOr.html#associatedtype.Output" title="type std::ops::BitOr::Output">Output</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, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitOr.html#associatedtype.Output" title="type std::ops::BitOr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#65-67' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>|</code> operation.</p>
</div></div><h3 id='impl-BitOr%3Ci32%3E-1' 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.i32.html">i32</a>> for &'a <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-BitOr%3Ci32%3E-1' class='anchor'></a></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.BitOr.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitOr.html#associatedtype.Output" title="type std::ops::BitOr::Output">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 class="primitive" href="primitive.i32.html">i32</a>) -> <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.BitOr.html" title="trait std::ops::BitOr">BitOr</a><<a class="primitive" href="primitive.i32.html">i32</a>>>::<a class="type" href="../std/ops/trait.BitOr.html#associatedtype.Output" title="type std::ops::BitOr::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#45-47' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>|</code> operation.</p>
</div></div><h3 id='impl-From%3Ci8%3E' 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.i32.html">i32</a></code><a href='#impl-From%3Ci8%3E' class='anchor'></a></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#3345-3350' 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.i8.html">i8</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3347-3349' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3Cu8%3E' 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.i32.html">i32</a></code><a href='#impl-From%3Cu8%3E' class='anchor'></a></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#3345-3350' 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.u8.html">u8</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3347-3349' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3Ci16%3E' 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.i16.html">i16</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-From%3Ci16%3E' class='anchor'></a></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#3345-3350' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.from-2' class="method"><span id='from.v-2' class='invisible'><code>fn <a href='../std/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(small: <a class="primitive" href="primitive.i16.html">i16</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3347-3349' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-From%3Cu16%3E' 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.u16.html">u16</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-From%3Cu16%3E' class='anchor'></a></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#3345-3350' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.from-3' class="method"><span id='from.v-3' class='invisible'><code>fn <a href='../std/convert/trait.From.html#tymethod.from' class='fnname'>from</a>(small: <a class="primitive" href="primitive.u16.html">u16</a>) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/num/mod.rs.html#3347-3349' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the conversion.</p>
</div></div><h3 id='impl-RemAssign%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-RemAssign%3Ci32%3E' class='anchor'></a></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/arith.rs.html#868-871' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#870' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>%=</code> operation.</p>
</div></div><h3 id='impl-RemAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.RemAssign.html" title="trait std::ops::RemAssign">RemAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-RemAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.rem_assign-1' class="method"><span id='rem_assign.v-1' class='invisible'><code>fn <a href='../std/ops/trait.RemAssign.html#tymethod.rem_assign' class='fnname'>rem_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>%=</code> operation.</p>
</div></div><h3 id='impl-DivAssign%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-DivAssign%3Ci32%3E' class='anchor'></a></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/arith.rs.html#820-823' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#822' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>/=</code> operation.</p>
</div></div><h3 id='impl-DivAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.DivAssign.html" title="trait std::ops::DivAssign">DivAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-DivAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.div_assign-1' class="method"><span id='div_assign.v-1' class='invisible'><code>fn <a href='../std/ops/trait.DivAssign.html#tymethod.div_assign' class='fnname'>div_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>/=</code> operation.</p>
</div></div><h3 id='impl-MulAssign%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-MulAssign%3Ci32%3E' class='anchor'></a></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/arith.rs.html#775-779' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#778' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>*=</code> operation.</p>
</div></div><h3 id='impl-MulAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.MulAssign.html" title="trait std::ops::MulAssign">MulAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-MulAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.mul_assign-1' class="method"><span id='mul_assign.v-1' class='invisible'><code>fn <a href='../std/ops/trait.MulAssign.html#tymethod.mul_assign' class='fnname'>mul_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>*=</code> operation.</p>
</div></div><h3 id='impl-SubAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.SubAssign.html" title="trait std::ops::SubAssign">SubAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-SubAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>-=</code> operation.</p>
</div></div><h3 id='impl-SubAssign%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-SubAssign%3Ci32%3E' class='anchor'></a></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/arith.rs.html#730-734' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.sub_assign-1' class="method"><span id='sub_assign.v-1' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#733' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>-=</code> operation.</p>
</div></div><h3 id='impl-AddAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.AddAssign.html" title="trait std::ops::AddAssign">AddAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-AddAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>+=</code> operation.</p>
</div></div><h3 id='impl-AddAssign%3Ci32%3E' 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.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-AddAssign%3Ci32%3E' class='anchor'></a></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/arith.rs.html#676-680' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.add_assign-1' class="method"><span id='add_assign.v-1' 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.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#679' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>+=</code> operation.</p>
</div></div><h3 id='impl-Neg' 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.i32.html">i32</a></code><a href='#impl-Neg' class='anchor'></a></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-130' class="type"><span id='Output.t-130' class='invisible'><code>type <a href='../std/ops/trait.Neg.html#associatedtype.Output' class="type">Output</a> = <<a class="primitive" href="primitive.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Neg.html" title="trait std::ops::Neg">Neg</a>>::<a class="type" href="../std/ops/trait.Neg.html#associatedtype.Output" title="type std::ops::Neg::Output">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.i32.html">i32</a> as <a class="trait" href="../std/ops/trait.Neg.html" title="trait std::ops::Neg">Neg</a>>::<a class="type" href="../std/ops/trait.Neg.html#associatedtype.Output" title="type std::ops::Neg::Output">Output</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#25-27' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the unary <code>-</code> operation.</p>
</div></div><h3 id='impl-Neg-1' 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.i32.html">i32</a></code><a href='#impl-Neg-1' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#607-613' 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.Neg.html#associatedtype.Output' class="type">Output</a> = <a class="primitive" href="primitive.i32.html">i32</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.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/arith.rs.html#612' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the unary <code>-</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Cu16%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Cu16%3E' class='anchor'></a></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/bit.rs.html#807-813' 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.u16.html">u16</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Ci16%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Ci16%3E' class='anchor'></a></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/bit.rs.html#807-813' 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.i16.html">i16</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20u64%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.u64.html">u64</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20u64%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.u64.html">u64</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Cu64%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Cu64%3E' class='anchor'></a></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/bit.rs.html#807-813' 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.u64.html">u64</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20i32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.i32.html">i32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20i32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.i32.html">i32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Cu32%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Cu32%3E' class='anchor'></a></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/bit.rs.html#807-813' 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.u32.html">u32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Cu128%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Cu128%3E' class='anchor'></a></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/bit.rs.html#807-813' 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.u128.html">u128</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20u8%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.u8.html">u8</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20u8%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.u8.html">u8</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Cusize%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Cusize%3E' class='anchor'></a></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/bit.rs.html#807-813' 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.usize.html">usize</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20isize%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.isize.html">isize</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20isize%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.isize.html">isize</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20i8%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.i8.html">i8</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20i8%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' 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 <a class="primitive" href="primitive.i8.html">i8</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Cisize%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Cisize%3E' class='anchor'></a></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/bit.rs.html#807-813' 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.isize.html">isize</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20i16%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.i16.html">i16</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20i16%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-12' class="method"><span id='shr_assign.v-12' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: &'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#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20i64%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.i64.html">i64</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20i64%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-13' class="method"><span id='shr_assign.v-13' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i64.html">i64</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Ci128%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Ci128%3E' class='anchor'></a></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/bit.rs.html#807-813' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-14' class="method"><span id='shr_assign.v-14' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20u16%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.u16.html">u16</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20u16%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-15' class="method"><span id='shr_assign.v-15' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.u16.html">u16</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Ci32%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Ci32%3E' class='anchor'></a></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/bit.rs.html#807-813' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-16' class="method"><span id='shr_assign.v-16' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20u32%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.u32.html">u32</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20u32%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-17' class="method"><span id='shr_assign.v-17' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.u32.html">u32</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Ci8%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Ci8%3E' class='anchor'></a></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/bit.rs.html#807-813' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-18' class="method"><span id='shr_assign.v-18' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Cu8%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Cu8%3E' class='anchor'></a></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/bit.rs.html#807-813' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-19' class="method"><span id='shr_assign.v-19' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20usize%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.usize.html">usize</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20usize%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-20' class="method"><span id='shr_assign.v-20' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.usize.html">usize</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3Ci64%3E' 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.i32.html">i32</a></code><a href='#impl-ShrAssign%3Ci64%3E' class='anchor'></a></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/bit.rs.html#807-813' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-21' class="method"><span id='shr_assign.v-21' 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><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/ops/bit.rs.html#810-812' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20i128%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.i128.html">i128</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20i128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-22' class="method"><span id='shr_assign.v-22' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.i128.html">i128</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-ShrAssign%3C%26%27a%20u128%3E' class='impl'><span class='in-band'><code>impl<'a> <a class="trait" href="../std/ops/trait.ShrAssign.html" title="trait std::ops::ShrAssign">ShrAssign</a><&'a <a class="primitive" href="primitive.u128.html">u128</a>> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-ShrAssign%3C%26%27a%20u128%3E' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><div class='since' title='Stable since Rust version 1.22.0'>1.22.0</div><a class='srclink' href='../src/core/internal_macros.rs.html#81-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.shr_assign-23' class="method"><span id='shr_assign.v-23' class='invisible'><code>fn <a href='../std/ops/trait.ShrAssign.html#tymethod.shr_assign' class='fnname'>shr_assign</a>(&mut self, other: &'a <a class="primitive" href="primitive.u128.html">u128</a>)</code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/core/internal_macros.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='docblock'><p>Performs the <code>>>=</code> operation.</p>
</div></div><h3 id='impl-Termination' class='impl'><span class='in-band'><code>impl <a class="trait" href="../std/trait.Termination.html" title="trait std::Termination">Termination</a> for <a class="primitive" href="primitive.i32.html">i32</a></code><a href='#impl-Termination' class='anchor'></a></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/std/termination.rs.html#82-86' title='goto source code'>[src]</a></span></h3>
<div class='impl-items'><h4 id='method.report' class="method"><span id='report.v' class='invisible'><code>fn <a href='../std/trait.Termination.html#tymethod.report' class='fnname'>report</a>(self) -> <a class="primitive" href="primitive.i32.html">i32</a></code></span><span class='out-of-band'><div class='ghost'></div><a class='srclink' href='../src/std/termination.rs.html#83-85' title='goto source code'>[src]</a></span></h4>
<div class='stability'><div class='stab unstable'><span class=microscope>🔬</span> This is a nightly-only experimental API. (<code>termination_trait </code><a href="https://github.com/rust-lang/rust/issues/43301">#43301</a>)</div></div><div class='docblock'><p>Is called to get the representation of the value as status code. This status code is returned to the operating system. <a href="../std/trait.Termination.html#tymethod.report">Read more</a></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><kbd>?</kbd></dt>
<dd>Show this help dialog</dd>
<dt><kbd>S</kbd></dt>
<dd>Focus the search field</dd>
<dt><kbd>↑</kbd></dt>
<dd>Move up in search results</dd>
<dt><kbd>↓</kbd></dt>
<dd>Move down in search results</dd>
<dt><kbd>↹</kbd></dt>
<dd>Switch tab</dd>
<dt><kbd>⏎</kbd></dt>
<dd>Go to active search result</dd>
<dt><kbd>+</kbd></dt>
<dd>Expand all sections</dd>
<dt><kbd>-</kbd></dt>
<dd>Collapse all sections</dd>
</dl>
</div>
<div class="infos">
<h2>Search Tricks</h2>
<p>
Prefix searches with a type followed by a colon (e.g.
<code>fn:</code>) to restrict the search to a given type.
</p>
<p>
Accepted types are: <code>fn</code>, <code>mod</code>,
<code>struct</code>, <code>enum</code>,
<code>trait</code>, <code>type</code>, <code>macro</code>,
and <code>const</code>.
</p>
<p>
Search functions by type signature (e.g.
<code>vec -> usize</code> or <code>* -> vec</code>)
</p>
</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
>
x86_64
>
media
>
core-updates
>
by-pkgid
>
fdedb3cf2140df9b6d419a2338ab1caa
>
files
>
5512
