wip add try from methods

Author: benmkw

src/lib.rs

@@ -1244,6 +1244,104 @@ from_primitive_integer!(u64, approximate_float_unsigned);
 from_primitive_integer!(u128, approximate_float_unsigned);
 from_primitive_integer!(usize, approximate_float_unsigned);
 
+macro_rules! try_from_impl {
+    ($typ:ty, $approx:ident) => {
+        // impl TryFrom<i32> for Ratio<$typ> {
+        //     type Error = ();
+        //     fn try_from(n: i32) -> Result<Self, ()> {
+        //         <$typ as FromPrimitive>::from_i32(n)
+        //             .map(Ratio::from_integer)
+        //             .ok_or(())
+        //     }
+        // }
+
+        impl TryFrom<i64> for Ratio<$typ> {
+            type Error = ();
+            fn try_from(n: i64) -> Result<Self, ()> {
+                <$typ as FromPrimitive>::from_i64(n)
+                    .map(Ratio::from_integer)
+                    .ok_or(())
+            }
+        }
+
+        impl TryFrom<i128> for Ratio<$typ> {
+            type Error = ();
+            fn try_from(n: i128) -> Result<Self, ()> {
+                <$typ as FromPrimitive>::from_i128(n)
+                    .map(Ratio::from_integer)
+                    .ok_or(())
+            }
+        }
+
+        // impl TryFrom<u32> for Ratio<$typ> {
+        //     type Error = ();
+        //     fn try_from(n: u32) -> Result<Self, ()> {
+        //         <$typ as FromPrimitive>::from_u32(n)
+        //             .map(Ratio::from_integer)
+        //             .ok_or(())
+        //     }
+        // }
+
+        impl TryFrom<u64> for Ratio<$typ> {
+            type Error = ();
+            fn try_from(n: u64) -> Result<Self, ()> {
+                <$typ as FromPrimitive>::from_u64(n)
+                    .map(Ratio::from_integer)
+                    .ok_or(())
+            }
+        }
+
+        impl TryFrom<u128> for Ratio<$typ> {
+            type Error = ();
+            fn try_from(n: u128) -> Result<Self, ()> {
+                <$typ as FromPrimitive>::from_u128(n)
+                    .map(Ratio::from_integer)
+                    .ok_or(())
+            }
+        }
+
+        impl TryFrom<f32> for Ratio<$typ> {
+            type Error = ();
+            fn try_from(n: f32) -> Result<Self, ()> {
+                $approx(n, 10e-20, 30).ok_or(())
+            }
+        }
+
+        impl TryFrom<f64> for Ratio<$typ> {
+            type Error = ();
+            fn try_from(n: f64) -> Result<Self, ()> {
+                $approx(n, 10e-20, 30).ok_or(())
+            }
+        }
+    };
+}
+use std::convert::TryFrom;
+
+// TODO
+// need to exclude generation of the version for the same value
+try_from_impl!(i8, approximate_float);
+try_from_impl!(i16, approximate_float);
+try_from_impl!(i32, approximate_float);
+// try_from_impl!(i64, approximate_float);
+// try_from_impl!(i128, approximate_float);
+try_from_impl!(isize, approximate_float);
+
+try_from_impl!(u8, approximate_float_unsigned);
+try_from_impl!(u16, approximate_float_unsigned);
+try_from_impl!(u32, approximate_float_unsigned);
+// try_from_impl!(u64, approximate_float_unsigned);
+// try_from_impl!(u128, approximate_float_unsigned);
+try_from_impl!(usize, approximate_float_unsigned);
+
+#[test]
+fn try_from_impl() {
+    debug_assert_eq!(Err(()), Ratio::<i8>::try_from(1000000i64));
+    debug_assert_eq!(
+        Ok(Ratio::<i8>::from_integer(11)),
+        Ratio::<i8>::try_from(11i64)
+    );
+}
+
 impl<T: Integer + Signed + Bounded + NumCast + Clone> Ratio<T> {
     pub fn approximate_float<F: FloatCore + NumCast>(f: F) -> Option<Ratio<T>> {
         // 1/10e-20 < 1/2**32 which seems like a good default, and 30 seems
@@ -2205,13 +2303,10 @@ mod test {
                 let big = T::max_value() / two.clone() / two.clone() * two.clone();
                 let _1_big: Ratio<T> = Ratio::new(T::one(), big.clone());
                 let _2_3: Ratio<T> = Ratio::new(two.clone(), _3.clone());
-                assert_eq!(None, big.clone().checked_mul(&_3.clone()));
+                assert_eq!(None, big.checked_mul(&_3));
                 let expected = Ratio::new(T::one(), big / two.clone() * _3.clone());
-                assert_eq!(expected.clone(), _1_big.clone() * _2_3.clone());
-                assert_eq!(
-                    Some(expected.clone()),
-                    _1_big.clone().checked_mul(&_2_3.clone())
-                );
+                assert_eq!(expected, _1_big.clone() * _2_3.clone());
+                assert_eq!(Some(expected.clone()), _1_big.checked_mul(&_2_3));
                 assert_eq!(expected, {
                     let mut tmp = _1_big;
                     tmp *= _2_3;
@@ -2221,7 +2316,7 @@ mod test {
                 // big/3 * 3 = big/1
                 // make big = max/2, but make it indivisible by 3
                 let big = T::max_value() / two / _3.clone() * _3.clone() + T::one();
-                assert_eq!(None, big.clone().checked_mul(&_3.clone()));
+                assert_eq!(None, big.checked_mul(&_3));
                 let big_3 = Ratio::new(big.clone(), _3.clone());
                 let expected = Ratio::new(big, T::one());
                 assert_eq!(expected, big_3.clone() * _3.clone());
@@ -2292,15 +2387,12 @@ mod test {
                 // 1/big / 3/2 = 1/(max/4*3), where big is max/2
                 // big ~ max/2, and big is divisible by 2
                 let big = T::max_value() / two.clone() / two.clone() * two.clone();
-                assert_eq!(None, big.clone().checked_mul(&_3.clone()));
+                assert_eq!(None, big.checked_mul(&_3));
                 let _1_big: Ratio<T> = Ratio::new(T::one(), big.clone());
                 let _3_two: Ratio<T> = Ratio::new(_3.clone(), two.clone());
                 let expected = Ratio::new(T::one(), big / two.clone() * _3.clone());
-                assert_eq!(expected.clone(), _1_big.clone() / _3_two.clone());
-                assert_eq!(
-                    Some(expected.clone()),
-                    _1_big.clone().checked_div(&_3_two.clone())
-                );
+                assert_eq!(expected, _1_big.clone() / _3_two.clone());
+                assert_eq!(Some(expected.clone()), _1_big.checked_div(&_3_two));
                 assert_eq!(expected, {
                     let mut tmp = _1_big;
                     tmp /= _3_two;
@@ -2310,7 +2402,7 @@ mod test {
                 // 3/big / 3 = 1/big where big is max/2
                 // big ~ max/2, and big is not divisible by 3
                 let big = T::max_value() / two / _3.clone() * _3.clone() + T::one();
-                assert_eq!(None, big.clone().checked_mul(&_3.clone()));
+                assert_eq!(None, big.checked_mul(&_3));
                 let _3_big = Ratio::new(_3.clone(), big.clone());
                 let expected = Ratio::new(T::one(), big);
                 assert_eq!(expected, _3_big.clone() / _3.clone());
@@ -2688,8 +2780,8 @@ mod test {
             1.0 / 2f32.powf(100.),
             ("1", "1267650600228229401496703205376"),
         );
-        test(684729.48391f32, ("1369459", "2"));
-        test(-8573.5918555f32, ("-4389679", "512"));
+        test(684_729.5_f32, ("1369459", "2"));
+        test(-8_573.592_f32, ("-4389679", "512"));
 
         // f64
         test(