OpenE2K/rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Rollup merge of #32873 - jethrogb:patch-2, r=steveklabnik

Browse Source 
Match signed/unsigned integer type docs

* Copy documentation from signed implementation to unsigned implementation, where necessary.

A few functions had elaborate docs in the signed version but not in the unsigned version. This probably happenned because the signed version is at the top and the author didn't realize they had to update the documentation in both locations.

* Use signed integers in signed documentation, where possible.

r? @steveklabnik
This commit is contained in:
Steve Klabnik 2016-04-11 10:31:28 -04:00
commit 55e90bbd5e
1 changed files with 53 additions and 41 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

94
src/libcore/num/mod.rs
View File

@ -149,7 +149,7 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// assert_eq!(u32::from_str_radix("A", 16), Ok(10));
/// assert_eq!(i32::from_str_radix("A", 16), Ok(10));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
@ -163,9 +163,9 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0b01001100u8;
/// let n = -0b1000_0000i8;
///
/// assert_eq!(n.count_ones(), 3);
/// assert_eq!(n.count_ones(), 1);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -178,9 +178,9 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0b01001100u8;
/// let n = -0b1000_0000i8;
///
/// assert_eq!(n.count_zeros(), 5);
/// assert_eq!(n.count_zeros(), 7);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -196,9 +196,9 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0b0101000u16;
/// let n = -1i16;
///
/// assert_eq!(n.leading_zeros(), 10);
/// assert_eq!(n.leading_zeros(), 0);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -214,9 +214,9 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0b0101000u16;
/// let n = -4i8;
///
/// assert_eq!(n.trailing_zeros(), 3);
/// assert_eq!(n.trailing_zeros(), 2);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -232,10 +232,10 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0x0123456789ABCDEFu64;
/// let m = 0x3456789ABCDEF012u64;
/// let n = 0x0123456789ABCDEFi64;
/// let m = -0x76543210FEDCBA99i64;
///
/// assert_eq!(n.rotate_left(12), m);
/// assert_eq!(n.rotate_left(32), m);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -252,10 +252,10 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0x0123456789ABCDEFu64;
/// let m = 0xDEF0123456789ABCu64;
/// let n = 0x0123456789ABCDEFi64;
/// let m = -0xFEDCBA987654322i64;
///
/// assert_eq!(n.rotate_right(12), m);
/// assert_eq!(n.rotate_right(4), m);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -270,8 +270,8 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0x0123456789ABCDEFu64;
/// let m = 0xEFCDAB8967452301u64;
/// let n = 0x0123456789ABCDEFi64;
/// let m = -0x1032547698BADCFFi64;
///
/// assert_eq!(n.swap_bytes(), m);
/// ```
@ -291,12 +291,12 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0x0123456789ABCDEFu64;
/// let n = 0x0123456789ABCDEFi64;
///
/// if cfg!(target_endian = "big") {
/// assert_eq!(u64::from_be(n), n)
/// assert_eq!(i64::from_be(n), n)
/// } else {
/// assert_eq!(u64::from_be(n), n.swap_bytes())
/// assert_eq!(i64::from_be(n), n.swap_bytes())
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
@ -315,12 +315,12 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0x0123456789ABCDEFu64;
/// let n = 0x0123456789ABCDEFi64;
///
/// if cfg!(target_endian = "little") {
/// assert_eq!(u64::from_le(n), n)
/// assert_eq!(i64::from_le(n), n)
/// } else {
/// assert_eq!(u64::from_le(n), n.swap_bytes())
/// assert_eq!(i64::from_le(n), n.swap_bytes())
/// }
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
@ -339,7 +339,7 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0x0123456789ABCDEFu64;
/// let n = 0x0123456789ABCDEFi64;
///
/// if cfg!(target_endian = "big") {
/// assert_eq!(n.to_be(), n)
@ -363,7 +363,7 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// let n = 0x0123456789ABCDEFu64;
/// let n = 0x0123456789ABCDEFi64;
///
/// if cfg!(target_endian = "little") {
/// assert_eq!(n.to_le(), n)
@ -385,8 +385,8 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// assert_eq!(5u16.checked_add(65530), Some(65535));
/// assert_eq!(6u16.checked_add(65530), None);
/// assert_eq!(7i16.checked_add(32760), Some(32767));
/// assert_eq!(8i16.checked_add(32760), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -421,8 +421,8 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// assert_eq!(5u8.checked_mul(51), Some(255));
/// assert_eq!(5u8.checked_mul(52), None);
/// assert_eq!(6i8.checked_mul(21), Some(126));
/// assert_eq!(6i8.checked_mul(22), None);
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
#[inline]
@ -753,8 +753,8 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// assert_eq!(1u8.wrapping_shl(7), 128);
/// assert_eq!(1u8.wrapping_shl(8), 1);
/// assert_eq!((-1i8).wrapping_shl(7), -128);
/// assert_eq!((-1i8).wrapping_shl(8), -1);
/// ```
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[inline(always)]
@ -778,8 +778,8 @@ macro_rules! int_impl {
/// Basic usage:
///
/// ```
/// assert_eq!(128u8.wrapping_shr(7), 1);
/// assert_eq!(128u8.wrapping_shr(8), 128);
/// assert_eq!((-128i8).wrapping_shr(7), -1);
/// assert_eq!((-128i8).wrapping_shr(8), -128);
/// ```
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[inline(always)]
@ -1193,15 +1193,13 @@ macro_rules! uint_impl {
///
/// Leading and trailing whitespace represent an error.
///
/// # Arguments
/// # Examples
///
/// * src - A string slice
/// * radix - The base to use. Must lie in the range [2 .. 36]
/// Basic usage:
///
/// # Return value
///
/// `Err(ParseIntError)` if the string did not represent a valid number.
/// Otherwise, `Ok(n)` where `n` is the integer represented by `src`.
/// ```
/// assert_eq!(u32::from_str_radix("A", 16), Ok(10));
/// ```
#[stable(feature = "rust1", since = "1.0.0")]
pub fn from_str_radix(src: &str, radix: u32) -> Result<Self, ParseIntError> {
from_str_radix(src, radix)
@ -1745,7 +1743,7 @@ macro_rules! uint_impl {
/// Basic usage:
///
/// ```
/// assert_eq!(100i8.wrapping_rem(10), 0);
/// assert_eq!(100u8.wrapping_rem(10), 0);
/// ```
#[stable(feature = "num_wrapping", since = "1.2.0")]
#[inline(always)]
@ -1783,6 +1781,13 @@ macro_rules! uint_impl {
/// where `mask` removes any high-order bits of `rhs` that
/// would cause the shift to exceed the bitwidth of the type.
///
/// Note that this is *not* 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 `rotate_left` function, which may
/// be what you want instead.
///
/// # Examples
///
/// Basic usage:
@ -1801,6 +1806,13 @@ macro_rules! uint_impl {
/// where `mask` removes any high-order bits of `rhs` that
/// would cause the shift to exceed the bitwidth of the type.
///
/// Note that this is *not* 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 `rotate_right` function, which may
/// be what you want instead.
///
/// # Examples
///
/// Basic usage: