Add full support for Saturating<T> closely matching that of Wrapping<T>

src/bounds.rs

@@ -124,6 +124,16 @@ impl<T: Bounded> Bounded for Wrapping<T> {
     }
 }
 
+#[cfg(has_num_saturating)]
+impl<T: Bounded> Bounded for core::num::Saturating<T> {
+    fn min_value() -> Self {
+        core::num::Saturating(T::min_value())
+    }
+    fn max_value() -> Self {
+        core::num::Saturating(T::max_value())
+    }
+}
+
 bounded_impl!(f32, f32::MIN, f32::MAX);
 
 macro_rules! for_each_tuple_ {
@@ -194,6 +204,44 @@ fn wrapping_is_bounded() {
     require_bounded(&Wrapping(-42));
 }
 
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_bounded() {
+    macro_rules! test_saturating_bounded {
+        ($($t:ty)+) => {
+            $(
+                assert_eq!(<core::num::Saturating<$t> as Bounded>::min_value().0, <$t>::min_value());
+                assert_eq!(<core::num::Saturating<$t> as Bounded>::max_value().0, <$t>::max_value());
+            )+
+        };
+    }
+
+    test_saturating_bounded!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_bounded_i128() {
+    macro_rules! test_saturating_bounded {
+        ($($t:ty)+) => {
+            $(
+                assert_eq!(<core::num::Saturating<$t> as Bounded>::min_value().0, <$t>::min_value());
+                assert_eq!(<core::num::Saturating<$t> as Bounded>::max_value().0, <$t>::max_value());
+            )+
+        };
+    }
+
+    test_saturating_bounded!(u128 i128);
+}
+
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_is_bounded() {
+    fn require_bounded<T: Bounded>(_: &T) {}
+    require_bounded(&core::num::Saturating(42_u32));
+    require_bounded(&core::num::Saturating(-42));
+}
+
 #[test]
 fn bounded_unsigned_nonzero() {
     macro_rules! test_bounded_impl_unsigned_nonzero {

src/cast.rs

@@ -695,7 +695,7 @@ impl_from_primitive_nonzero!(NonZeroU32, to_u32);
 impl_from_primitive_nonzero!(NonZeroU64, to_u64);
 impl_from_primitive_nonzero!(NonZeroU128, to_u128);
 
-macro_rules! impl_to_primitive_wrapping {
+macro_rules! impl_to_primitive_for_wrapper {
     ($( fn $method:ident -> $i:ident ; )*) => {$(
         #[inline]
         fn $method(&self) -> Option<$i> {
@@ -705,7 +705,7 @@ macro_rules! impl_to_primitive_wrapping {
 }
 
 impl<T: ToPrimitive> ToPrimitive for Wrapping<T> {
-    impl_to_primitive_wrapping! {
+    impl_to_primitive_for_wrapper! {
         fn to_isize -> isize;
         fn to_i8 -> i8;
         fn to_i16 -> i16;
@@ -725,17 +725,39 @@ impl<T: ToPrimitive> ToPrimitive for Wrapping<T> {
     }
 }
 
-macro_rules! impl_from_primitive_wrapping {
-    ($( fn $method:ident ( $i:ident ); )*) => {$(
+macro_rules! impl_from_primitive_for_wrapper {
+    ($wrapper:path, $( fn $method:ident ( $i:ident ); )*) => {$(
         #[inline]
         fn $method(n: $i) -> Option<Self> {
-            T::$method(n).map(Wrapping)
+            T::$method(n).map($wrapper)
         }
     )*}
 }
 
 impl<T: FromPrimitive> FromPrimitive for Wrapping<T> {
-    impl_from_primitive_wrapping! {
+    impl_from_primitive_for_wrapper! { Wrapping,
+        fn from_isize(isize);
+        fn from_i8(i8);
+        fn from_i16(i16);
+        fn from_i32(i32);
+        fn from_i64(i64);
+        fn from_i128(i128);
+
+        fn from_usize(usize);
+        fn from_u8(u8);
+        fn from_u16(u16);
+        fn from_u32(u32);
+        fn from_u64(u64);
+        fn from_u128(u128);
+
+        fn from_f32(f32);
+        fn from_f64(f64);
+    }
+}
+
+#[cfg(has_num_saturating)]
+impl<T: FromPrimitive> FromPrimitive for core::num::Saturating<T> {
+    impl_from_primitive_for_wrapper! { core::num::Saturating,
         fn from_isize(isize);
         fn from_i8(i8);
         fn from_i16(i16);
@@ -844,6 +866,35 @@ impl<T: NumCast> NumCast for Wrapping<T> {
     }
 }
 
+#[cfg(has_num_saturating)]
+impl<T: ToPrimitive> ToPrimitive for core::num::Saturating<T> {
+    impl_to_primitive_for_wrapper! {
+        fn to_isize -> isize;
+        fn to_i8 -> i8;
+        fn to_i16 -> i16;
+        fn to_i32 -> i32;
+        fn to_i64 -> i64;
+        fn to_i128 -> i128;
+
+        fn to_usize -> usize;
+        fn to_u8 -> u8;
+        fn to_u16 -> u16;
+        fn to_u32 -> u32;
+        fn to_u64 -> u64;
+        fn to_u128 -> u128;
+
+        fn to_f32 -> f32;
+        fn to_f64 -> f64;
+    }
+}
+
+#[cfg(has_num_saturating)]
+impl<T: NumCast> NumCast for core::num::Saturating<T> {
+    fn from<U: ToPrimitive>(n: U) -> Option<Self> {
+        T::from(n).map(core::num::Saturating)
+    }
+}
+
 /// A generic interface for casting between machine scalars with the
 /// `as` operator, which admits narrowing and precision loss.
 /// Implementers of this trait `AsPrimitive` should behave like a primitive

src/ops/saturating.rs

@@ -107,6 +107,36 @@ saturating_impl!(SaturatingMul, saturating_mul, i128);
 
 // TODO: add SaturatingNeg for signed integer primitives once the saturating_neg() API is stable.
 
+#[cfg(has_num_saturating)]
+impl<T: SaturatingAdd> SaturatingAdd for core::num::Saturating<T>
+where
+    core::num::Saturating<T>: Add<Output = core::num::Saturating<T>>,
+{
+    fn saturating_add(&self, v: &Self) -> Self {
+        core::num::Saturating(self.0.saturating_add(&v.0))
+    }
+}
+
+#[cfg(has_num_saturating)]
+impl<T: SaturatingSub> SaturatingSub for core::num::Saturating<T>
+where
+    core::num::Saturating<T>: Sub<Output = core::num::Saturating<T>>,
+{
+    fn saturating_sub(&self, v: &Self) -> Self {
+        core::num::Saturating(self.0.saturating_sub(&v.0))
+    }
+}
+
+#[cfg(has_num_saturating)]
+impl<T: SaturatingMul> SaturatingMul for core::num::Saturating<T>
+where
+    core::num::Saturating<T>: Mul<Output = core::num::Saturating<T>>,
+{
+    fn saturating_mul(&self, v: &Self) -> Self {
+        core::num::Saturating(self.0.saturating_mul(&v.0))
+    }
+}
+
 #[test]
 fn test_saturating_traits() {
     fn saturating_add<T: SaturatingAdd>(a: T, b: T) -> T {
@@ -128,3 +158,24 @@ fn test_saturating_traits() {
     assert_eq!(saturating_mul(127, 2), 127i8);
     assert_eq!(saturating_mul(-128, 2), -128i8);
 }
+
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_is_saturatingadd() {
+    fn require_saturatingadd<T: SaturatingAdd>(_: &T) {}
+    require_saturatingadd(&core::num::Saturating(42));
+}
+
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_is_saturatingsub() {
+    fn require_saturatingsub<T: SaturatingSub>(_: &T) {}
+    require_saturatingsub(&core::num::Saturating(42));
+}
+
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_is_saturatingmul() {
+    fn require_saturatingmul<T: SaturatingMul>(_: &T) {}
+    require_saturatingmul(&core::num::Saturating(42));
+}

src/pow.rs

@@ -130,6 +130,31 @@ pow_impl!(Wrapping<i128>);
 pow_impl!(Wrapping<usize>);
 pow_impl!(Wrapping<isize>);
 
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<u8>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<i8>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<u16>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<i16>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<u32>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<i32>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<u64>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<i64>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<u128>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<i128>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<usize>);
+#[cfg(has_num_saturating)]
+pow_impl!(core::num::Saturating<isize>);
+
 // FIXME: these should be possible
 // pow_impl!(u8, u64);
 // pow_impl!(i16, u64);

src/sign.rs

@@ -1,3 +1,5 @@
+#[cfg(has_num_saturating)]
+use core::num::Saturating;
 use core::num::Wrapping;
 use core::ops::Neg;
 
@@ -104,6 +106,37 @@ where
     }
 }
 
+#[cfg(has_num_saturating)]
+impl<T: Signed> Signed for Saturating<T>
+where
+    Saturating<T>: Num + Neg<Output = Saturating<T>>,
+{
+    #[inline]
+    fn abs(&self) -> Self {
+        Saturating(self.0.abs())
+    }
+
+    #[inline]
+    fn abs_sub(&self, other: &Self) -> Self {
+        Saturating(self.0.abs_sub(&other.0))
+    }
+
+    #[inline]
+    fn signum(&self) -> Self {
+        Saturating(self.0.signum())
+    }
+
+    #[inline]
+    fn is_positive(&self) -> bool {
+        self.0.is_positive()
+    }
+
+    #[inline]
+    fn is_negative(&self) -> bool {
+        self.0.is_negative()
+    }
+}
+
 macro_rules! signed_float_impl {
     ($t:ty) => {
         impl Signed for $t {
@@ -203,6 +236,9 @@ empty_trait_impl!(Unsigned for usize u8 u16 u32 u64 u128);
 
 impl<T: Unsigned> Unsigned for Wrapping<T> where Wrapping<T>: Num {}
 
+#[cfg(has_num_saturating)]
+impl<T: Unsigned> Unsigned for Saturating<T> where Saturating<T>: Num {}
+
 #[test]
 fn unsigned_wrapping_is_unsigned() {
     fn require_unsigned<T: Unsigned>(_: &T) {}
@@ -214,3 +250,17 @@ fn signed_wrapping_is_signed() {
     fn require_signed<T: Signed>(_: &T) {}
     require_signed(&Wrapping(-42));
 }
+
+#[test]
+#[cfg(has_num_saturating)]
+fn unsigned_saturating_is_unsigned() {
+    fn require_unsigned<T: Unsigned>(_: &T) {}
+    require_unsigned(&Saturating(42_u32));
+}
+
+#[test]
+#[cfg(has_num_saturating)]
+fn signed_saturating_is_signed() {
+    fn require_signed<T: Signed>(_: &T) {}
+    require_signed(&Saturating(-42));
+}

tests/cast.rs

@@ -73,6 +73,62 @@ fn wrapping_is_numcast() {
     require_numcast(&Wrapping(42));
 }
 
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_to_primitive() {
+    use core::num::Saturating;
+
+    macro_rules! test_saturating_to_primitive {
+        ($($t:ty)+) => {
+            $({
+                let i: $t = 0;
+                let w = Saturating(i);
+                assert_eq!(i.to_u8(),    w.to_u8());
+                assert_eq!(i.to_u16(),   w.to_u16());
+                assert_eq!(i.to_u32(),   w.to_u32());
+                assert_eq!(i.to_u64(),   w.to_u64());
+                assert_eq!(i.to_usize(), w.to_usize());
+                assert_eq!(i.to_i8(),    w.to_i8());
+                assert_eq!(i.to_i16(),   w.to_i16());
+                assert_eq!(i.to_i32(),   w.to_i32());
+                assert_eq!(i.to_i64(),   w.to_i64());
+                assert_eq!(i.to_isize(), w.to_isize());
+                assert_eq!(i.to_f32(),   w.to_f32());
+                assert_eq!(i.to_f64(),   w.to_f64());
+            })+
+        };
+    }
+
+    test_saturating_to_primitive!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_is_toprimitive() {
+    use core::num::Saturating;
+
+    fn require_toprimitive<T: ToPrimitive>(_: &T) {}
+    require_toprimitive(&Saturating(42));
+}
+
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_is_fromprimitive() {
+    use core::num::Saturating;
+
+    fn require_fromprimitive<T: FromPrimitive>(_: &T) {}
+    require_fromprimitive(&Saturating(42));
+}
+
+#[test]
+#[cfg(has_num_saturating)]
+fn saturating_is_numcast() {
+    use core::num::Saturating;
+
+    fn require_numcast<T: NumCast>(_: &T) {}
+    require_numcast(&Saturating(42));
+}
+
 #[test]
 fn as_primitive() {
     let x: f32 = (1.625f64).as_();