num_traits/ops/
checked.rs

1use core::ops::{Add, Div, Mul, Rem, Shl, Shr, Sub};
2
3/// Performs addition that returns `None` instead of wrapping around on
4/// overflow.
5pub trait CheckedAdd: Sized + Add<Self, Output = Self> {
6    /// Adds two numbers, checking for overflow. If overflow happens, `None` is
7    /// returned.
8    fn checked_add(&self, v: &Self) -> Option<Self>;
9}
10
11macro_rules! checked_impl {
12    ($trait_name:ident, $method:ident, $t:ty) => {
13        impl $trait_name for $t {
14            #[inline]
15            fn $method(&self, v: &$t) -> Option<$t> {
16                <$t>::$method(*self, *v)
17            }
18        }
19    };
20}
21
22impl CheckedAdd for u8 {
    #[inline]
    fn checked_add(&self, v: &u8) -> Option<u8> {
        <u8>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, u8);
23impl CheckedAdd for u16 {
    #[inline]
    fn checked_add(&self, v: &u16) -> Option<u16> {
        <u16>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, u16);
24impl CheckedAdd for u32 {
    #[inline]
    fn checked_add(&self, v: &u32) -> Option<u32> {
        <u32>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, u32);
25impl CheckedAdd for u64 {
    #[inline]
    fn checked_add(&self, v: &u64) -> Option<u64> {
        <u64>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, u64);
26impl CheckedAdd for usize {
    #[inline]
    fn checked_add(&self, v: &usize) -> Option<usize> {
        <usize>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, usize);
27impl CheckedAdd for u128 {
    #[inline]
    fn checked_add(&self, v: &u128) -> Option<u128> {
        <u128>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, u128);
28
29impl CheckedAdd for i8 {
    #[inline]
    fn checked_add(&self, v: &i8) -> Option<i8> {
        <i8>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, i8);
30impl CheckedAdd for i16 {
    #[inline]
    fn checked_add(&self, v: &i16) -> Option<i16> {
        <i16>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, i16);
31impl CheckedAdd for i32 {
    #[inline]
    fn checked_add(&self, v: &i32) -> Option<i32> {
        <i32>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, i32);
32impl CheckedAdd for i64 {
    #[inline]
    fn checked_add(&self, v: &i64) -> Option<i64> {
        <i64>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, i64);
33impl CheckedAdd for isize {
    #[inline]
    fn checked_add(&self, v: &isize) -> Option<isize> {
        <isize>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, isize);
34impl CheckedAdd for i128 {
    #[inline]
    fn checked_add(&self, v: &i128) -> Option<i128> {
        <i128>::checked_add(*self, *v)
    }
}checked_impl!(CheckedAdd, checked_add, i128);
35
36/// Performs subtraction that returns `None` instead of wrapping around on underflow.
37pub trait CheckedSub: Sized + Sub<Self, Output = Self> {
38    /// Subtracts two numbers, checking for underflow. If underflow happens,
39    /// `None` is returned.
40    fn checked_sub(&self, v: &Self) -> Option<Self>;
41}
42
43impl CheckedSub for u8 {
    #[inline]
    fn checked_sub(&self, v: &u8) -> Option<u8> {
        <u8>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, u8);
44impl CheckedSub for u16 {
    #[inline]
    fn checked_sub(&self, v: &u16) -> Option<u16> {
        <u16>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, u16);
45impl CheckedSub for u32 {
    #[inline]
    fn checked_sub(&self, v: &u32) -> Option<u32> {
        <u32>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, u32);
46impl CheckedSub for u64 {
    #[inline]
    fn checked_sub(&self, v: &u64) -> Option<u64> {
        <u64>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, u64);
47impl CheckedSub for usize {
    #[inline]
    fn checked_sub(&self, v: &usize) -> Option<usize> {
        <usize>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, usize);
48impl CheckedSub for u128 {
    #[inline]
    fn checked_sub(&self, v: &u128) -> Option<u128> {
        <u128>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, u128);
49
50impl CheckedSub for i8 {
    #[inline]
    fn checked_sub(&self, v: &i8) -> Option<i8> {
        <i8>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, i8);
51impl CheckedSub for i16 {
    #[inline]
    fn checked_sub(&self, v: &i16) -> Option<i16> {
        <i16>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, i16);
52impl CheckedSub for i32 {
    #[inline]
    fn checked_sub(&self, v: &i32) -> Option<i32> {
        <i32>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, i32);
53impl CheckedSub for i64 {
    #[inline]
    fn checked_sub(&self, v: &i64) -> Option<i64> {
        <i64>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, i64);
54impl CheckedSub for isize {
    #[inline]
    fn checked_sub(&self, v: &isize) -> Option<isize> {
        <isize>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, isize);
55impl CheckedSub for i128 {
    #[inline]
    fn checked_sub(&self, v: &i128) -> Option<i128> {
        <i128>::checked_sub(*self, *v)
    }
}checked_impl!(CheckedSub, checked_sub, i128);
56
57/// Performs multiplication that returns `None` instead of wrapping around on underflow or
58/// overflow.
59pub trait CheckedMul: Sized + Mul<Self, Output = Self> {
60    /// Multiplies two numbers, checking for underflow or overflow. If underflow
61    /// or overflow happens, `None` is returned.
62    fn checked_mul(&self, v: &Self) -> Option<Self>;
63}
64
65impl CheckedMul for u8 {
    #[inline]
    fn checked_mul(&self, v: &u8) -> Option<u8> {
        <u8>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, u8);
66impl CheckedMul for u16 {
    #[inline]
    fn checked_mul(&self, v: &u16) -> Option<u16> {
        <u16>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, u16);
67impl CheckedMul for u32 {
    #[inline]
    fn checked_mul(&self, v: &u32) -> Option<u32> {
        <u32>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, u32);
68impl CheckedMul for u64 {
    #[inline]
    fn checked_mul(&self, v: &u64) -> Option<u64> {
        <u64>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, u64);
69impl CheckedMul for usize {
    #[inline]
    fn checked_mul(&self, v: &usize) -> Option<usize> {
        <usize>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, usize);
70impl CheckedMul for u128 {
    #[inline]
    fn checked_mul(&self, v: &u128) -> Option<u128> {
        <u128>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, u128);
71
72impl CheckedMul for i8 {
    #[inline]
    fn checked_mul(&self, v: &i8) -> Option<i8> {
        <i8>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, i8);
73impl CheckedMul for i16 {
    #[inline]
    fn checked_mul(&self, v: &i16) -> Option<i16> {
        <i16>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, i16);
74impl CheckedMul for i32 {
    #[inline]
    fn checked_mul(&self, v: &i32) -> Option<i32> {
        <i32>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, i32);
75impl CheckedMul for i64 {
    #[inline]
    fn checked_mul(&self, v: &i64) -> Option<i64> {
        <i64>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, i64);
76impl CheckedMul for isize {
    #[inline]
    fn checked_mul(&self, v: &isize) -> Option<isize> {
        <isize>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, isize);
77impl CheckedMul for i128 {
    #[inline]
    fn checked_mul(&self, v: &i128) -> Option<i128> {
        <i128>::checked_mul(*self, *v)
    }
}checked_impl!(CheckedMul, checked_mul, i128);
78
79/// Performs division that returns `None` instead of panicking on division by zero and instead of
80/// wrapping around on underflow and overflow.
81pub trait CheckedDiv: Sized + Div<Self, Output = Self> {
82    /// Divides two numbers, checking for underflow, overflow and division by
83    /// zero. If any of that happens, `None` is returned.
84    fn checked_div(&self, v: &Self) -> Option<Self>;
85}
86
87impl CheckedDiv for u8 {
    #[inline]
    fn checked_div(&self, v: &u8) -> Option<u8> {
        <u8>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, u8);
88impl CheckedDiv for u16 {
    #[inline]
    fn checked_div(&self, v: &u16) -> Option<u16> {
        <u16>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, u16);
89impl CheckedDiv for u32 {
    #[inline]
    fn checked_div(&self, v: &u32) -> Option<u32> {
        <u32>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, u32);
90impl CheckedDiv for u64 {
    #[inline]
    fn checked_div(&self, v: &u64) -> Option<u64> {
        <u64>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, u64);
91impl CheckedDiv for usize {
    #[inline]
    fn checked_div(&self, v: &usize) -> Option<usize> {
        <usize>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, usize);
92impl CheckedDiv for u128 {
    #[inline]
    fn checked_div(&self, v: &u128) -> Option<u128> {
        <u128>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, u128);
93
94impl CheckedDiv for i8 {
    #[inline]
    fn checked_div(&self, v: &i8) -> Option<i8> {
        <i8>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, i8);
95impl CheckedDiv for i16 {
    #[inline]
    fn checked_div(&self, v: &i16) -> Option<i16> {
        <i16>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, i16);
96impl CheckedDiv for i32 {
    #[inline]
    fn checked_div(&self, v: &i32) -> Option<i32> {
        <i32>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, i32);
97impl CheckedDiv for i64 {
    #[inline]
    fn checked_div(&self, v: &i64) -> Option<i64> {
        <i64>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, i64);
98impl CheckedDiv for isize {
    #[inline]
    fn checked_div(&self, v: &isize) -> Option<isize> {
        <isize>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, isize);
99impl CheckedDiv for i128 {
    #[inline]
    fn checked_div(&self, v: &i128) -> Option<i128> {
        <i128>::checked_div(*self, *v)
    }
}checked_impl!(CheckedDiv, checked_div, i128);
100
101/// Performs an integral remainder that returns `None` instead of panicking on division by zero and
102/// instead of wrapping around on underflow and overflow.
103pub trait CheckedRem: Sized + Rem<Self, Output = Self> {
104    /// Finds the remainder of dividing two numbers, checking for underflow, overflow and division
105    /// by zero. If any of that happens, `None` is returned.
106    ///
107    /// # Examples
108    ///
109    /// ```
110    /// use num_traits::CheckedRem;
111    /// use std::i32::MIN;
112    ///
113    /// assert_eq!(CheckedRem::checked_rem(&10, &7), Some(3));
114    /// assert_eq!(CheckedRem::checked_rem(&10, &-7), Some(3));
115    /// assert_eq!(CheckedRem::checked_rem(&-10, &7), Some(-3));
116    /// assert_eq!(CheckedRem::checked_rem(&-10, &-7), Some(-3));
117    ///
118    /// assert_eq!(CheckedRem::checked_rem(&10, &0), None);
119    ///
120    /// assert_eq!(CheckedRem::checked_rem(&MIN, &1), Some(0));
121    /// assert_eq!(CheckedRem::checked_rem(&MIN, &-1), None);
122    /// ```
123    fn checked_rem(&self, v: &Self) -> Option<Self>;
124}
125
126impl CheckedRem for u8 {
    #[inline]
    fn checked_rem(&self, v: &u8) -> Option<u8> {
        <u8>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, u8);
127impl CheckedRem for u16 {
    #[inline]
    fn checked_rem(&self, v: &u16) -> Option<u16> {
        <u16>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, u16);
128impl CheckedRem for u32 {
    #[inline]
    fn checked_rem(&self, v: &u32) -> Option<u32> {
        <u32>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, u32);
129impl CheckedRem for u64 {
    #[inline]
    fn checked_rem(&self, v: &u64) -> Option<u64> {
        <u64>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, u64);
130impl CheckedRem for usize {
    #[inline]
    fn checked_rem(&self, v: &usize) -> Option<usize> {
        <usize>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, usize);
131impl CheckedRem for u128 {
    #[inline]
    fn checked_rem(&self, v: &u128) -> Option<u128> {
        <u128>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, u128);
132
133impl CheckedRem for i8 {
    #[inline]
    fn checked_rem(&self, v: &i8) -> Option<i8> {
        <i8>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, i8);
134impl CheckedRem for i16 {
    #[inline]
    fn checked_rem(&self, v: &i16) -> Option<i16> {
        <i16>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, i16);
135impl CheckedRem for i32 {
    #[inline]
    fn checked_rem(&self, v: &i32) -> Option<i32> {
        <i32>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, i32);
136impl CheckedRem for i64 {
    #[inline]
    fn checked_rem(&self, v: &i64) -> Option<i64> {
        <i64>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, i64);
137impl CheckedRem for isize {
    #[inline]
    fn checked_rem(&self, v: &isize) -> Option<isize> {
        <isize>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, isize);
138impl CheckedRem for i128 {
    #[inline]
    fn checked_rem(&self, v: &i128) -> Option<i128> {
        <i128>::checked_rem(*self, *v)
    }
}checked_impl!(CheckedRem, checked_rem, i128);
139
140macro_rules! checked_impl_unary {
141    ($trait_name:ident, $method:ident, $t:ty) => {
142        impl $trait_name for $t {
143            #[inline]
144            fn $method(&self) -> Option<$t> {
145                <$t>::$method(*self)
146            }
147        }
148    };
149}
150
151/// Performs negation that returns `None` if the result can't be represented.
152pub trait CheckedNeg: Sized {
153    /// Negates a number, returning `None` for results that can't be represented, like signed `MIN`
154    /// values that can't be positive, or non-zero unsigned values that can't be negative.
155    ///
156    /// # Examples
157    ///
158    /// ```
159    /// use num_traits::CheckedNeg;
160    /// use std::i32::MIN;
161    ///
162    /// assert_eq!(CheckedNeg::checked_neg(&1_i32), Some(-1));
163    /// assert_eq!(CheckedNeg::checked_neg(&-1_i32), Some(1));
164    /// assert_eq!(CheckedNeg::checked_neg(&MIN), None);
165    ///
166    /// assert_eq!(CheckedNeg::checked_neg(&0_u32), Some(0));
167    /// assert_eq!(CheckedNeg::checked_neg(&1_u32), None);
168    /// ```
169    fn checked_neg(&self) -> Option<Self>;
170}
171
172impl CheckedNeg for u8 {
    #[inline]
    fn checked_neg(&self) -> Option<u8> { <u8>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, u8);
173impl CheckedNeg for u16 {
    #[inline]
    fn checked_neg(&self) -> Option<u16> { <u16>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, u16);
174impl CheckedNeg for u32 {
    #[inline]
    fn checked_neg(&self) -> Option<u32> { <u32>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, u32);
175impl CheckedNeg for u64 {
    #[inline]
    fn checked_neg(&self) -> Option<u64> { <u64>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, u64);
176impl CheckedNeg for usize {
    #[inline]
    fn checked_neg(&self) -> Option<usize> { <usize>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, usize);
177impl CheckedNeg for u128 {
    #[inline]
    fn checked_neg(&self) -> Option<u128> { <u128>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, u128);
178
179impl CheckedNeg for i8 {
    #[inline]
    fn checked_neg(&self) -> Option<i8> { <i8>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, i8);
180impl CheckedNeg for i16 {
    #[inline]
    fn checked_neg(&self) -> Option<i16> { <i16>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, i16);
181impl CheckedNeg for i32 {
    #[inline]
    fn checked_neg(&self) -> Option<i32> { <i32>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, i32);
182impl CheckedNeg for i64 {
    #[inline]
    fn checked_neg(&self) -> Option<i64> { <i64>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, i64);
183impl CheckedNeg for isize {
    #[inline]
    fn checked_neg(&self) -> Option<isize> { <isize>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, isize);
184impl CheckedNeg for i128 {
    #[inline]
    fn checked_neg(&self) -> Option<i128> { <i128>::checked_neg(*self) }
}checked_impl_unary!(CheckedNeg, checked_neg, i128);
185
186/// Performs a left shift that returns `None` on shifts larger than
187/// or equal to the type width.
188pub trait CheckedShl: Sized + Shl<u32, Output = Self> {
189    /// Checked shift left. Computes `self << rhs`, returning `None`
190    /// if `rhs` is larger than or equal to the number of bits in `self`.
191    ///
192    /// ```
193    /// use num_traits::CheckedShl;
194    ///
195    /// let x: u16 = 0x0001;
196    ///
197    /// assert_eq!(CheckedShl::checked_shl(&x, 0),  Some(0x0001));
198    /// assert_eq!(CheckedShl::checked_shl(&x, 1),  Some(0x0002));
199    /// assert_eq!(CheckedShl::checked_shl(&x, 15), Some(0x8000));
200    /// assert_eq!(CheckedShl::checked_shl(&x, 16), None);
201    /// ```
202    fn checked_shl(&self, rhs: u32) -> Option<Self>;
203}
204
205macro_rules! checked_shift_impl {
206    ($trait_name:ident, $method:ident, $t:ty) => {
207        impl $trait_name for $t {
208            #[inline]
209            fn $method(&self, rhs: u32) -> Option<$t> {
210                <$t>::$method(*self, rhs)
211            }
212        }
213    };
214}
215
216impl CheckedShl for u8 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<u8> {
        <u8>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, u8);
217impl CheckedShl for u16 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<u16> {
        <u16>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, u16);
218impl CheckedShl for u32 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<u32> {
        <u32>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, u32);
219impl CheckedShl for u64 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<u64> {
        <u64>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, u64);
220impl CheckedShl for usize {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<usize> {
        <usize>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, usize);
221impl CheckedShl for u128 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<u128> {
        <u128>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, u128);
222
223impl CheckedShl for i8 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<i8> {
        <i8>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, i8);
224impl CheckedShl for i16 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<i16> {
        <i16>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, i16);
225impl CheckedShl for i32 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<i32> {
        <i32>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, i32);
226impl CheckedShl for i64 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<i64> {
        <i64>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, i64);
227impl CheckedShl for isize {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<isize> {
        <isize>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, isize);
228impl CheckedShl for i128 {
    #[inline]
    fn checked_shl(&self, rhs: u32) -> Option<i128> {
        <i128>::checked_shl(*self, rhs)
    }
}checked_shift_impl!(CheckedShl, checked_shl, i128);
229
230/// Performs a right shift that returns `None` on shifts larger than
231/// or equal to the type width.
232pub trait CheckedShr: Sized + Shr<u32, Output = Self> {
233    /// Checked shift right. Computes `self >> rhs`, returning `None`
234    /// if `rhs` is larger than or equal to the number of bits in `self`.
235    ///
236    /// ```
237    /// use num_traits::CheckedShr;
238    ///
239    /// let x: u16 = 0x8000;
240    ///
241    /// assert_eq!(CheckedShr::checked_shr(&x, 0),  Some(0x8000));
242    /// assert_eq!(CheckedShr::checked_shr(&x, 1),  Some(0x4000));
243    /// assert_eq!(CheckedShr::checked_shr(&x, 15), Some(0x0001));
244    /// assert_eq!(CheckedShr::checked_shr(&x, 16), None);
245    /// ```
246    fn checked_shr(&self, rhs: u32) -> Option<Self>;
247}
248
249impl CheckedShr for u8 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<u8> {
        <u8>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, u8);
250impl CheckedShr for u16 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<u16> {
        <u16>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, u16);
251impl CheckedShr for u32 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<u32> {
        <u32>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, u32);
252impl CheckedShr for u64 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<u64> {
        <u64>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, u64);
253impl CheckedShr for usize {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<usize> {
        <usize>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, usize);
254impl CheckedShr for u128 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<u128> {
        <u128>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, u128);
255
256impl CheckedShr for i8 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<i8> {
        <i8>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, i8);
257impl CheckedShr for i16 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<i16> {
        <i16>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, i16);
258impl CheckedShr for i32 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<i32> {
        <i32>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, i32);
259impl CheckedShr for i64 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<i64> {
        <i64>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, i64);
260impl CheckedShr for isize {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<isize> {
        <isize>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, isize);
261impl CheckedShr for i128 {
    #[inline]
    fn checked_shr(&self, rhs: u32) -> Option<i128> {
        <i128>::checked_shr(*self, rhs)
    }
}checked_shift_impl!(CheckedShr, checked_shr, i128);
num_traits/ops/checked.rs

num_traits/ops/
checked.rs
