Generic implementation for Sum and Product

The succestion came from @cupiver, and it was simple and elegant. Now it
should be possible to use `std::iter::{Sum, Product}` with everything
that can be Add`-ed and `Mul`-tiplied _against_ `BigInt` and `BigUint`

src/macros.rs

@@ -317,42 +317,32 @@ macro_rules! promote_all_scalars {
 
 macro_rules! impl_sum_iter_type {
     ($res:ty) => {
-        impl Sum for $res {
-            impl_sum_iter_type!($res, $res);
-        }
-
-        impl<'a> Sum<&'a $res> for $res {
-            impl_sum_iter_type!($res, &'a $res);
-        }
-    };
-
-    ($res:ty, $item:ty) => {
-        fn sum<I>(iter: I) -> Self
+        impl<T> Sum<T> for $res
         where
-            I: Iterator<Item = $item>
+            $res: Add<T, Output=Self>
         {
-            iter.fold(Zero::zero(), <$res>::add)
+            fn sum<I>(iter: I) -> Self
+            where
+                I: Iterator<Item = T>
+            {
+                iter.fold(Zero::zero(), <$res>::add)
+            }
         }
     };
 }
 
 macro_rules! impl_product_iter_type {
     ($res:ty) => {
-        impl Product for $res {
-            impl_product_iter_type!($res, $res);
-        }
-
-        impl<'a> Product<&'a $res> for $res {
-            impl_product_iter_type!($res, &'a $res);
-        }
-    };
-
-    ($res:ty, $item:ty) => {
-        fn product<I>(iter: I) -> Self
+        impl<T> Product<T> for $res
         where
-            I: Iterator<Item = $item>
+            $res: Mul<T, Output=Self>
         {
-            iter.fold(One::one(), <$res>::mul)
+            fn product<I>(iter: I) -> Self
+            where
+                I: Iterator<Item = T>
+            {
+                iter.fold(One::one(), <$res>::mul)
+            }
         }
     };
 }

src/tests/bigint.rs

@@ -1225,3 +1225,23 @@ fn test_iter_product() {
     assert_eq!(result, data.iter().product());
     assert_eq!(result, data.into_iter().product());
 }
+
+#[test]
+fn test_iter_sum_generic() {
+    let result: BigInt = FromPrimitive::from_isize(-1234567).unwrap();
+    let data = vec![-1000000, -200000, -30000, -4000, -500, -60, -7];
+
+    assert_eq!(result, data.iter().sum());
+    assert_eq!(result, data.into_iter().sum());
+}
+
+#[test]
+fn test_iter_product_generic() {
+    let data = vec![1001, -1002, 1003, -1004, 1005];
+    let result = data[0].to_bigint().unwrap() * data[1].to_bigint().unwrap()
+        * data[2].to_bigint().unwrap() * data[3].to_bigint().unwrap()
+        * data[4].to_bigint().unwrap();
+
+    assert_eq!(result, data.iter().product());
+    assert_eq!(result, data.into_iter().product());
+}

src/tests/biguint.rs

@@ -1709,3 +1709,23 @@ fn test_iter_product() {
     assert_eq!(result, data.iter().product());
     assert_eq!(result, data.into_iter().product());
 }
+
+#[test]
+fn test_iter_sum_generic() {
+    let result: BigUint = FromPrimitive::from_isize(1234567).unwrap();
+    let data = vec![1000000_u32, 200000, 30000, 4000, 500, 60, 7];
+
+    assert_eq!(result, data.iter().sum());
+    assert_eq!(result, data.into_iter().sum());
+}
+
+#[test]
+fn test_iter_product_generic() {
+    let data = vec![1001_u32, 1002, 1003, 1004, 1005];
+    let result = data[0].to_biguint().unwrap() * data[1].to_biguint().unwrap()
+        * data[2].to_biguint().unwrap() * data[3].to_biguint().unwrap()
+        * data[4].to_biguint().unwrap();
+
+    assert_eq!(result, data.iter().product());
+    assert_eq!(result, data.into_iter().product());
+}