feat: implement num_trait gaps Bounded, NumCast, ConstZero, ConstOne…

Cargo.toml

@@ -28,7 +28,7 @@ bytemuck_derive = { default-features = false, optional = true, version = "1.7.1"
 bytes = { default-features = false, optional = true, version = "1.0" }
 diesel = { default-features = false, optional = true, version = "2.2.3" }
 ndarray = { default-features = false, optional = true, version = "0.15.6" }
-num-traits = { default-features = false, features = ["i128"], version = "0.2" }
+num-traits = { default-features = false, features = ["i128"], version = "0.2.18" }
 postgres-types = { default-features = false, optional = true, version = "0.2" }
 proptest = { default-features = false, optional = true, features = ["std"], version = "1.0" }
 rand = { default-features = false, optional = true, version = "0.8" }

src/arithmetic_impls.rs

@@ -3,7 +3,9 @@
 
 use crate::{decimal::CalculationResult, ops, Decimal};
 use core::ops::{Add, Div, Mul, Rem, Sub};
-use num_traits::{CheckedAdd, CheckedDiv, CheckedMul, CheckedRem, CheckedSub, Inv};
+use num_traits::{
+    CheckedAdd, CheckedDiv, CheckedMul, CheckedRem, CheckedSub, Inv, SaturatingAdd, SaturatingMul, SaturatingSub,
+};
 
 // Macros and `Decimal` implementations
 
@@ -198,6 +200,27 @@ impl CheckedRem for Decimal {
     }
 }
 
+impl SaturatingAdd for Decimal {
+    #[inline]
+    fn saturating_add(&self, v: &Decimal) -> Decimal {
+        Decimal::saturating_add(*self, *v)
+    }
+}
+
+impl SaturatingSub for Decimal {
+    #[inline]
+    fn saturating_sub(&self, v: &Decimal) -> Decimal {
+        Decimal::saturating_sub(*self, *v)
+    }
+}
+
+impl SaturatingMul for Decimal {
+    #[inline]
+    fn saturating_mul(&self, v: &Decimal) -> Decimal {
+        Decimal::saturating_mul(*self, *v)
+    }
+}
+
 impl Inv for Decimal {
     type Output = Self;
 

src/decimal.rs

@@ -20,7 +20,7 @@ use diesel::{deserialize::FromSqlRow, expression::AsExpression, sql_types::Numer
 #[allow(unused_imports)] // It's not actually dead code below, but the compiler thinks it is.
 #[cfg(not(feature = "std"))]
 use num_traits::float::FloatCore;
-use num_traits::{FromPrimitive, Num, One, Signed, ToPrimitive, Zero};
+use num_traits::{Bounded, ConstOne, ConstZero, FromPrimitive, Num, One, Signed, ToPrimitive, Zero};
 #[cfg(feature = "rkyv")]
 use rkyv::{Archive, Deserialize, Serialize};
 #[cfg(all(target_arch = "wasm32", feature = "wasm"))]
@@ -2041,6 +2041,14 @@ impl One for Decimal {
     }
 }
 
+impl ConstZero for Decimal {
+    const ZERO: Self = Decimal::ZERO;
+}
+
+impl ConstOne for Decimal {
+    const ONE: Self = Decimal::ONE;
+}
+
 impl Signed for Decimal {
     fn abs(&self) -> Self {
         self.abs()
@@ -2083,6 +2091,22 @@ impl Num for Decimal {
     }
 }
 
+impl Bounded for Decimal {
+    fn min_value() -> Self {
+        Decimal::MIN
+    }
+
+    fn max_value() -> Self {
+        Decimal::MAX
+    }
+}
+
+impl num_traits::NumCast for Decimal {
+    fn from<T: ToPrimitive>(n: T) -> Option<Self> {
+        n.to_f64().and_then(<Decimal as FromPrimitive>::from_f64)
+    }
+}
+
 impl FromStr for Decimal {
     type Err = Error;
 

src/lib.rs

@@ -72,7 +72,7 @@ pub mod prelude {
     pub use crate::maths::MathematicalOps;
     pub use crate::{Decimal, RoundingStrategy};
     pub use core::str::FromStr;
-    pub use num_traits::{FromPrimitive, One, Signed, ToPrimitive, Zero};
+    pub use num_traits::{Bounded, FromPrimitive, One, Signed, ToPrimitive, Zero};
 }
 
 #[cfg(feature = "macros")]

tests/decimal_tests.rs

@@ -4882,3 +4882,101 @@ mod issues {
         assert_result(29, a, b);
     }
 }
+
+mod num_traits_impls {
+    use core::str::FromStr;
+    use num_traits::{Bounded, ConstOne, ConstZero, NumCast, SaturatingAdd, SaturatingMul, SaturatingSub};
+    use rust_decimal::Decimal;
+
+    #[test]
+    fn bounded_min_max() {
+        assert_eq!(<Decimal as Bounded>::min_value(), Decimal::MIN);
+        assert_eq!(<Decimal as Bounded>::max_value(), Decimal::MAX);
+    }
+
+    #[test]
+    fn const_zero_and_one_usable_in_const_context() {
+        const Z: Decimal = <Decimal as ConstZero>::ZERO;
+        const O: Decimal = <Decimal as ConstOne>::ONE;
+        assert_eq!(Z, Decimal::ZERO);
+        assert_eq!(O, Decimal::ONE);
+    }
+
+    #[test]
+    fn bounded_in_prelude() {
+        use rust_decimal::prelude::*;
+        let _: Decimal = Bounded::min_value();
+        let _: Decimal = Bounded::max_value();
+    }
+
+    #[test]
+    fn num_cast_from_integers() {
+        assert_eq!(<Decimal as NumCast>::from(0i8), Some(Decimal::ZERO));
+        assert_eq!(<Decimal as NumCast>::from(-1i8), Some(Decimal::NEGATIVE_ONE));
+        assert_eq!(<Decimal as NumCast>::from(1i32), Some(Decimal::ONE));
+        assert_eq!(<Decimal as NumCast>::from(42u64), Decimal::from_str("42").ok());
+        assert_eq!(<Decimal as NumCast>::from(100i128), Decimal::from_str("100").ok());
+    }
+
+    #[test]
+    fn num_cast_from_floats() {
+        assert_eq!(<Decimal as NumCast>::from(0.0f32), Some(Decimal::ZERO));
+        assert_eq!(<Decimal as NumCast>::from(1.5f64), Decimal::from_str("1.5").ok());
+        assert_eq!(<Decimal as NumCast>::from(-2.25f64), Decimal::from_str("-2.25").ok());
+    }
+
+    #[test]
+    fn num_cast_rejects_non_finite_and_out_of_range() {
+        assert_eq!(<Decimal as NumCast>::from(f64::NAN), None);
+        assert_eq!(<Decimal as NumCast>::from(f64::INFINITY), None);
+        assert_eq!(<Decimal as NumCast>::from(f64::NEG_INFINITY), None);
+        // Decimal::MAX is ~7.9e28; 1e30 sits above it.
+        assert_eq!(<Decimal as NumCast>::from(1.0e30f64), None);
+        assert_eq!(<Decimal as NumCast>::from(-1.0e30f64), None);
+    }
+
+    #[test]
+    fn saturating_add_normal_and_overflow() {
+        let a = Decimal::from_str("1.5").unwrap();
+        let b = Decimal::from_str("2.5").unwrap();
+        assert_eq!(SaturatingAdd::saturating_add(&a, &b), Decimal::from_str("4.0").unwrap());
+        assert_eq!(
+            SaturatingAdd::saturating_add(&Decimal::MAX, &Decimal::ONE),
+            Decimal::MAX
+        );
+        assert_eq!(
+            SaturatingAdd::saturating_add(&Decimal::MIN, &Decimal::NEGATIVE_ONE),
+            Decimal::MIN
+        );
+    }
+
+    #[test]
+    fn saturating_sub_normal_and_overflow() {
+        let a = Decimal::from_str("5").unwrap();
+        let b = Decimal::from_str("2").unwrap();
+        assert_eq!(SaturatingSub::saturating_sub(&a, &b), Decimal::from_str("3").unwrap());
+        assert_eq!(
+            SaturatingSub::saturating_sub(&Decimal::MIN, &Decimal::ONE),
+            Decimal::MIN
+        );
+        assert_eq!(
+            SaturatingSub::saturating_sub(&Decimal::MAX, &Decimal::NEGATIVE_ONE),
+            Decimal::MAX
+        );
+    }
+
+    #[test]
+    fn saturating_mul_normal_and_overflow() {
+        let a = Decimal::from_str("3").unwrap();
+        let b = Decimal::from_str("4").unwrap();
+        assert_eq!(SaturatingMul::saturating_mul(&a, &b), Decimal::from_str("12").unwrap());
+        assert_eq!(
+            SaturatingMul::saturating_mul(&Decimal::MAX, &Decimal::TWO),
+            Decimal::MAX
+        );
+        assert_eq!(
+            SaturatingMul::saturating_mul(&Decimal::MIN, &Decimal::TWO),
+            Decimal::MIN
+        );
+    }
+}