dec: add to/from u/i+8/16

Author: Sean Loiselle

dec/src/decimal.rs

@@ -703,6 +703,46 @@ macro_rules! decnum_tryinto_primitive_uint {
     }};
 }
 
+/// Refer to the comments on [`Context<Decimal<N>>::try_into_i32()`], which also apply to
+/// this trait.
+impl<const N: usize> TryFrom<Decimal<N>> for i8 {
+    type Error = TryFromDecimalError;
+    fn try_from(n: Decimal<N>) -> Result<i8, Self::Error> {
+        let mut cx = Context::<Decimal<N>>::default();
+        cx.try_into_i8(n)
+    }
+}
+
+/// Refer to the comments on [`Context<Decimal<N>>::try_into_i32()`], which also apply to
+/// this trait.
+impl<const N: usize> TryFrom<Decimal<N>> for u8 {
+    type Error = TryFromDecimalError;
+    fn try_from(n: Decimal<N>) -> Result<u8, Self::Error> {
+        let mut cx = Context::<Decimal<N>>::default();
+        cx.try_into_u8(n)
+    }
+}
+
+/// Refer to the comments on [`Context<Decimal<N>>::try_into_i32()`], which also apply to
+/// this trait.
+impl<const N: usize> TryFrom<Decimal<N>> for i16 {
+    type Error = TryFromDecimalError;
+    fn try_from(n: Decimal<N>) -> Result<i16, Self::Error> {
+        let mut cx = Context::<Decimal<N>>::default();
+        cx.try_into_i16(n)
+    }
+}
+
+/// Refer to the comments on [`Context<Decimal<N>>::try_into_i32()`], which also apply to
+/// this trait.
+impl<const N: usize> TryFrom<Decimal<N>> for u16 {
+    type Error = TryFromDecimalError;
+    fn try_from(n: Decimal<N>) -> Result<u16, Self::Error> {
+        let mut cx = Context::<Decimal<N>>::default();
+        cx.try_into_u16(n)
+    }
+}
+
 /// Refer to the comments on [`Context<Decimal<N>>::try_into_i32()`], which also apply to
 /// this trait.
 impl<const N: usize> TryFrom<Decimal<N>> for i32 {
@@ -856,6 +896,30 @@ impl<const N: usize> From<f64> for Decimal<N> {
     }
 }
 
+impl<const N: usize> From<i8> for Decimal<N> {
+    fn from(n: i8) -> Decimal<N> {
+        Decimal::<N>::from(i32::from(n))
+    }
+}
+
+impl<const N: usize> From<u8> for Decimal<N> {
+    fn from(n: u8) -> Decimal<N> {
+        Decimal::<N>::from(u32::from(n))
+    }
+}
+
+impl<const N: usize> From<i16> for Decimal<N> {
+    fn from(n: i16) -> Decimal<N> {
+        Decimal::<N>::from(i32::from(n))
+    }
+}
+
+impl<const N: usize> From<u16> for Decimal<N> {
+    fn from(n: u16) -> Decimal<N> {
+        Decimal::<N>::from(u32::from(n))
+    }
+}
+
 impl<const N: usize> From<i32> for Decimal<N> {
     fn from(n: i32) -> Decimal<N> {
         let mut d = Decimal::default();
@@ -1284,6 +1348,42 @@ impl<const N: usize> Context<Decimal<N>> {
         decimal_from_unsigned_int!(self, n)
     }
 
+    /// Attempts to convert `d` to `u8` or fails if not possible.
+    ///
+    /// Refer to the comments on [`Self::try_into_i32()`], which also apply to this
+    /// function.
+    pub fn try_into_u8(&mut self, d: Decimal<N>) -> Result<u8, TryFromDecimalError> {
+        let i = self.try_into_u32(d)?;
+        u8::try_from(i).map_err(|_| TryFromDecimalError)
+    }
+
+    /// Attempts to convert `d` to `i8` or fails if not possible.
+    ///
+    /// Refer to the comments on [`Self::try_into_i32()`], which also apply to this
+    /// function.
+    pub fn try_into_i8(&mut self, d: Decimal<N>) -> Result<i8, TryFromDecimalError> {
+        let i = self.try_into_i32(d)?;
+        i8::try_from(i).map_err(|_| TryFromDecimalError)
+    }
+
+    /// Attempts to convert `d` to `u16` or fails if not possible.
+    ///
+    /// Refer to the comments on [`Self::try_into_i32()`], which also apply to this
+    /// function.
+    pub fn try_into_u16(&mut self, d: Decimal<N>) -> Result<u16, TryFromDecimalError> {
+        let i = self.try_into_u32(d)?;
+        u16::try_from(i).map_err(|_| TryFromDecimalError)
+    }
+
+    /// Attempts to convert `d` to `i16` or fails if not possible.
+    ///
+    /// Refer to the comments on [`Self::try_into_i32()`], which also apply to this
+    /// function.
+    pub fn try_into_i16(&mut self, d: Decimal<N>) -> Result<i16, TryFromDecimalError> {
+        let i = self.try_into_i32(d)?;
+        i16::try_from(i).map_err(|_| TryFromDecimalError)
+    }
+
     /// Attempts to convert `d` to `i32` or fails if not possible. Note that
     /// when returning an error, `self`'s [`context::Status`] is set to
     /// `invalid_operation` in addition to using Rust's `Err` return value.

dec/tests/dec.rs

@@ -1558,6 +1558,14 @@ fn test_cx_into_u128() {
 fn test_decnum_tryinto_primitive() {
     const WIDTH: usize = 14;
     let mut cx = Context::<Decimal<WIDTH>>::default();
+    let min_u8 = Decimal::<WIDTH>::from(u8::MIN);
+    let max_u8 = Decimal::<WIDTH>::from(u8::MAX);
+    let min_i8 = Decimal::<WIDTH>::from(i8::MIN);
+    let max_i8 = Decimal::<WIDTH>::from(i8::MAX);
+    let min_u16 = Decimal::<WIDTH>::from(u16::MIN);
+    let max_u16 = Decimal::<WIDTH>::from(u16::MAX);
+    let min_i16 = Decimal::<WIDTH>::from(i16::MIN);
+    let max_i16 = Decimal::<WIDTH>::from(i16::MAX);
     let min_u32 = Decimal::<WIDTH>::from(u32::MIN);
     let max_u32 = Decimal::<WIDTH>::from(u32::MAX);
     let min_i32 = Decimal::<WIDTH>::from(i32::MIN);
@@ -1575,13 +1583,45 @@ fn test_decnum_tryinto_primitive() {
     let scientific_notation = cx.parse("2E5").unwrap();
 
     let inner = |v: &Decimal<WIDTH>| {
+        let i_u8 = u8::try_from(*v);
+        let i_i8 = i8::try_from(*v);
+        let i_u16 = u16::try_from(*v);
+        let i_i16 = i16::try_from(*v);
         let i_u32 = u32::try_from(*v);
         let i_i32 = i32::try_from(*v);
         let i_u64 = u64::try_from(*v);
         let i_i64 = i64::try_from(*v);
         let i_u128 = u128::try_from(*v);
         let i_i128 = i128::try_from(*v);
 
+        // u8
+        if v >= &min_u8 && v <= &max_u8 {
+            assert!(i_u8.is_ok());
+        } else {
+            assert!(i_u8.is_err());
+        }
+
+        // i8
+        if v >= &min_i8 && v <= &max_i8 {
+            assert!(i_i8.is_ok());
+        } else {
+            assert!(i_i8.is_err());
+        }
+
+        // u16
+        if v >= &min_u16 && v <= &max_u16 {
+            assert!(i_u16.is_ok());
+        } else {
+            assert!(i_u16.is_err());
+        }
+
+        // i16
+        if v >= &min_i16 && v <= &max_i16 {
+            assert!(i_i16.is_ok());
+        } else {
+            assert!(i_i16.is_err());
+        }
+
         // u32
         if v >= &min_u32 && v <= &max_u32 {
             assert!(i_u32.is_ok());
@@ -1644,12 +1684,6 @@ fn test_decnum_tryinto_primitive() {
     fn inner_expect_failure(s: &str) {
         let mut cx = Context::<Decimal<WIDTH>>::default();
         let v = cx.parse(s).unwrap();
-        println!(
-            "v {:?}, v.exponent {}, v.digits {}",
-            v,
-            v.exponent(),
-            v.digits()
-        );
         assert!(u32::try_from(v).is_err());
         assert!(i32::try_from(v).is_err());
         assert!(u64::try_from(v).is_err());