Add Sum and Product impls for Wrapping

cristicbz · cristicbz · commit df0e5a97fb32 · 2016-10-23T14:29:38.000+01:00
diff --git a/src/libcore/iter/traits.rs b/src/libcore/iter/traits.rs
@@ -8,6 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 use ops::{Mul, Add};
+use num::Wrapping;
 
 /// Conversion from an `Iterator`.
 ///
@@ -584,35 +585,39 @@ pub trait Product<A = Self>: Sized {
 
 // NB: explicitly use Add and Mul here to inherit overflow checks
 macro_rules! integer_sum_product {
-    ($($a:ident)*) => ($(
+    (@impls $zero:expr, $one:expr, $($a:ty)*) => ($(
         #[stable(feature = "iter_arith_traits", since = "1.12.0")]
         impl Sum for $a {
             fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {
-                iter.fold(0, Add::add)
+                iter.fold($zero, Add::add)
             }
         }
 
         #[stable(feature = "iter_arith_traits", since = "1.12.0")]
         impl Product for $a {
             fn product<I: Iterator<Item=$a>>(iter: I) -> $a {
-                iter.fold(1, Mul::mul)
+                iter.fold($one, Mul::mul)
             }
         }
 
         #[stable(feature = "iter_arith_traits", since = "1.12.0")]
         impl<'a> Sum<&'a $a> for $a {
             fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
-                iter.cloned().fold(0, Add::add)
+                iter.fold($zero, Add::add)
             }
         }
 
         #[stable(feature = "iter_arith_traits", since = "1.12.0")]
         impl<'a> Product<&'a $a> for $a {
             fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {
-                iter.cloned().fold(1, Mul::mul)
+                iter.fold($one, Mul::mul)
             }
         }
-    )*)
+    )*);
+    ($($a:ty)*) => (
+        integer_sum_product!(@impls 0, 1, $($a)+);
+        integer_sum_product!(@impls Wrapping(0), Wrapping(1), $(Wrapping<$a>)+);
+    );
 }
 
 macro_rules! float_sum_product {

Original file line number	Diff line number	Diff line change
`@@ -8,6 +8,7 @@`
`8`	`8`	`// option. This file may not be copied, modified, or distributed`
`9`	`9`	`// except according to those terms.`
`10`	`10`	`use ops::{Mul, Add};`
	`11`	`+use num::Wrapping;`
`11`	`12`
`12`	`13`	/// Conversion from an `Iterator`.
`13`	`14`	`///`
`@@ -584,35 +585,39 @@ pub trait Product<A = Self>: Sized {`
`584`	`585`
`585`	`586`	`// NB: explicitly use Add and Mul here to inherit overflow checks`
`586`	`587`	`macro_rules! integer_sum_product {`
`587`		`- ($($a:ident)*) => ($(`
	`588`	`+ (@impls $zero:expr, $one:expr, $($a:ty)*) => ($(`
`588`	`589`	`#[stable(feature = "iter_arith_traits", since = "1.12.0")]`
`589`	`590`	`impl Sum for $a {`
`590`	`591`	`fn sum<I: Iterator<Item=$a>>(iter: I) -> $a {`
`591`		`- iter.fold(0, Add::add)`
	`592`	`+ iter.fold($zero, Add::add)`
`592`	`593`	`}`
`593`	`594`	`}`
`594`	`595`
`595`	`596`	`#[stable(feature = "iter_arith_traits", since = "1.12.0")]`
`596`	`597`	`impl Product for $a {`
`597`	`598`	`fn product<I: Iterator<Item=$a>>(iter: I) -> $a {`
`598`		`- iter.fold(1, Mul::mul)`
	`599`	`+ iter.fold($one, Mul::mul)`
`599`	`600`	`}`
`600`	`601`	`}`
`601`	`602`
`602`	`603`	`#[stable(feature = "iter_arith_traits", since = "1.12.0")]`
`603`	`604`	`impl<'a> Sum<&'a $a> for $a {`
`604`	`605`	`fn sum<I: Iterator<Item=&'a $a>>(iter: I) -> $a {`
`605`		`- iter.cloned().fold(0, Add::add)`
	`606`	`+ iter.fold($zero, Add::add)`
`606`	`607`	`}`
`607`	`608`	`}`
`608`	`609`
`609`	`610`	`#[stable(feature = "iter_arith_traits", since = "1.12.0")]`
`610`	`611`	`impl<'a> Product<&'a $a> for $a {`
`611`	`612`	`fn product<I: Iterator<Item=&'a $a>>(iter: I) -> $a {`
`612`		`- iter.cloned().fold(1, Mul::mul)`
	`613`	`+ iter.fold($one, Mul::mul)`
`613`	`614`	`}`
`614`	`615`	`}`
`615`		`- )*)`
	`616`	`+ )*);`
	`617`	`+ ($($a:ty)*) => (`
	`618`	`+ integer_sum_product!(@impls 0, 1, $($a)+);`
	`619`	`+ integer_sum_product!(@impls Wrapping(0), Wrapping(1), $(Wrapping<$a>)+);`
	`620`	`+ );`
`616`	`621`	`}`
`617`	`622`
`618`	`623`	`macro_rules! float_sum_product {`