     1
     2
     3
     4
     5
     6
     7
     8
     9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    41
    42
    43
    44
    45
    46
    47
    48
    49
    50
    51
    52
    53
    54
    55
    56
    57
    58
    59
    60
    61
    62
    63
    64
    65
    66
    67
    68
    69
    70
    71
    72
    73
    74
    75
    76
    77
    78
    79
    80
    81
    82
    83
    84
    85
    86
    87
    88
    89
    90
    91
    92

    use std::ops::{Add, Sub, Mul, Div};

    /// Performs addition that returns `None` instead of wrapping around on
    /// overflow.
    pub trait CheckedAdd: Sized + Add<Self, Output=Self> {
        /// Adds two numbers, checking for overflow. If overflow happens, `None` is
        /// returned.
        fn checked_add(&self, v: &Self) -> Option<Self>;
    }

    macro_rules! checked_impl {
        ($trait_name:ident, $method:ident, $t:ty) => {
            impl $trait_name for $t {
                #[inline]
                fn $method(&self, v: &$t) -> Option<$t> {
                    <$t>::$method(*self, *v)
                }
            }
        }
    }

    checked_impl!(CheckedAdd, checked_add, u8);
    checked_impl!(CheckedAdd, checked_add, u16);
    checked_impl!(CheckedAdd, checked_add, u32);
    checked_impl!(CheckedAdd, checked_add, u64);
    checked_impl!(CheckedAdd, checked_add, usize);

    checked_impl!(CheckedAdd, checked_add, i8);
    checked_impl!(CheckedAdd, checked_add, i16);
    checked_impl!(CheckedAdd, checked_add, i32);
    checked_impl!(CheckedAdd, checked_add, i64);
    checked_impl!(CheckedAdd, checked_add, isize);

    /// Performs subtraction that returns `None` instead of wrapping around on underflow.
    pub trait CheckedSub: Sized + Sub<Self, Output=Self> {
        /// Subtracts two numbers, checking for underflow. If underflow happens,
        /// `None` is returned.
        fn checked_sub(&self, v: &Self) -> Option<Self>;
    }

    checked_impl!(CheckedSub, checked_sub, u8);
    checked_impl!(CheckedSub, checked_sub, u16);
    checked_impl!(CheckedSub, checked_sub, u32);
    checked_impl!(CheckedSub, checked_sub, u64);
    checked_impl!(CheckedSub, checked_sub, usize);

    checked_impl!(CheckedSub, checked_sub, i8);
    checked_impl!(CheckedSub, checked_sub, i16);
    checked_impl!(CheckedSub, checked_sub, i32);
    checked_impl!(CheckedSub, checked_sub, i64);
    checked_impl!(CheckedSub, checked_sub, isize);

    /// Performs multiplication that returns `None` instead of wrapping around on underflow or
    /// overflow.
    pub trait CheckedMul: Sized + Mul<Self, Output=Self> {
        /// Multiplies two numbers, checking for underflow or overflow. If underflow
        /// or overflow happens, `None` is returned.
        fn checked_mul(&self, v: &Self) -> Option<Self>;
    }

    checked_impl!(CheckedMul, checked_mul, u8);
    checked_impl!(CheckedMul, checked_mul, u16);
    checked_impl!(CheckedMul, checked_mul, u32);
    checked_impl!(CheckedMul, checked_mul, u64);
    checked_impl!(CheckedMul, checked_mul, usize);

    checked_impl!(CheckedMul, checked_mul, i8);
    checked_impl!(CheckedMul, checked_mul, i16);
    checked_impl!(CheckedMul, checked_mul, i32);
    checked_impl!(CheckedMul, checked_mul, i64);
    checked_impl!(CheckedMul, checked_mul, isize);

    /// Performs division that returns `None` instead of panicking on division by zero and instead of
    /// wrapping around on underflow and overflow.
    pub trait CheckedDiv: Sized + Div<Self, Output=Self> {
        /// Divides two numbers, checking for underflow, overflow and division by
        /// zero. If any of that happens, `None` is returned.
        fn checked_div(&self, v: &Self) -> Option<Self>;
    }

    checked_impl!(CheckedDiv, checked_div, u8);
    checked_impl!(CheckedDiv, checked_div, u16);
    checked_impl!(CheckedDiv, checked_div, u32);
    checked_impl!(CheckedDiv, checked_div, u64);
    checked_impl!(CheckedDiv, checked_div, usize);

    checked_impl!(CheckedDiv, checked_div, i8);
    checked_impl!(CheckedDiv, checked_div, i16);
    checked_impl!(CheckedDiv, checked_div, i32);
    checked_impl!(CheckedDiv, checked_div, i64);
    checked_impl!(CheckedDiv, checked_div, isize);

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)