Add CheckedSum and CheckedProduct traits

src/iter/checked_product.rs

@@ -0,0 +1,87 @@
+use crate::identities::One;
+use crate::CheckedMul;
+
+/// Trait to represent types that can be created by multiplying elements of an iterator with overflow checking.
+/// This trait should rarely be called directly.
+pub trait CheckedProduct<A = Self> : Sized {
+ /// Method which takes an iterator and generates Self from the elements by multiplying the items with overflow checking, returning `None` if the multiplication would overflow.
+ ///
+ /// An empty iterator returns the one value of the type.
+ ///
+ /// For iterators containing zero, the order of elements may effect whether the result is `None`.
+ fn checked_product<I: Iterator<Item = A>>(iter: I) -> Option<Self>;
+}
+
+impl<T> CheckedProduct<T> for T
+where
+ T: CheckedMul + One,
+{
+ fn checked_product<I: Iterator<Item = Self>>(mut iter: I) -> Option<Self> {
+ iter.try_fold(Self::one(), |acc, x| acc.checked_mul(&x))
+ }
+}
+
+impl<'a, T> CheckedProduct<&'a T> for T
+where
+ T: CheckedMul + One,
+{
+ fn checked_product<I: Iterator<Item = &'a Self>>(mut iter: I) -> Option<Self> {
+ iter.try_fold(Self::one(), |acc, x| acc.checked_mul(&x))
+ }
+}
+
+#[test]
+fn checked_product_returns_none_instead_of_overflowing() {
+ use crate::iter::num_iter::NumIter;
+
+ macro_rules! test_checked_product {
+ ($($t:ty)+) => {
+ $(
+ assert_eq!(None::<$t>, [<$t>::MAX, 2 ].iter().checked_product() );
+ assert_eq!(None::<$t>,IntoIterator::into_iter([<$t>::MAX, 2]).checked_product() );
+ )+
+ };
+ }
+
+ test_checked_product!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+fn checked_product_returns_one_if_empty() {
+ use crate::iter::num_iter::NumIter;
+
+ macro_rules! test_checked_product {
+ ($($t:ty)+) => {
+ $(
+ assert_eq!(Some(<$t>::one()), ([] as [$t; 0]).iter().checked_product() );
+ assert_eq!(Some(<$t>::one()),IntoIterator::into_iter(([] as [$t; 0])).checked_product() );
+ )+
+ };
+ }
+
+ test_checked_product!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+fn checked_product_returns_correct_product() {
+ use crate::iter::num_iter::NumIter;
+
+ macro_rules! test_checked_product {
+ ($($t:ty)+) => {
+ $(
+ assert_eq!(Some(42), ([3,7,2] as [$t; 3]).iter().checked_product() );
+ assert_eq!(Some(42),IntoIterator::into_iter(([3,7,2] as [$t; 3])).checked_product() );
+ )+
+ };
+ }
+
+ test_checked_product!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+fn checked_product_multiplies_left_to_right() {
+ use crate::iter::num_iter::NumIter;
+
+ assert_eq!(None::<u8>, [100u8, 3u8, 0u8].iter().checked_product());
+ assert_eq!(Some(0), [0u8, 100u8, 3u8].iter().checked_product());
+}

src/iter/checked_sum.rs

@@ -0,0 +1,89 @@
+use crate::identities::Zero;
+use crate::CheckedAdd;
+
+/// Trait to represent types that can be created by summing up an iterator with overflow checking.
+/// This trait should rarely be called directly.
+pub trait CheckedSum<A = Self>: Sized {
+ /// Method which takes an iterator and generates Self from the elements by “summing up” the items with overflow checking, returning `None` if the addition would overflow.
+ ///
+ /// An empty iterator returns the one value of the type.
+ ///
+ /// For signed numbers, the order of elements may effect whether the result is `None`.
+ fn checked_sum<I: Iterator<Item = A>>(iter: I) -> Option<Self>;
+}
+
+impl<T> CheckedSum<T> for T
+where
+ T: CheckedAdd + Zero,
+{
+ fn checked_sum<I: Iterator<Item = Self>>(mut iter: I) -> Option<Self> {
+ iter.try_fold(Self::zero(), |acc, x| acc.checked_add(&x))
+ }
+}
+
+impl<'a, T> CheckedSum<&'a T> for T
+where
+ T: CheckedAdd + Zero,
+{
+ fn checked_sum<I: Iterator<Item = &'a Self>>(mut iter: I) -> Option<Self> {
+ iter.try_fold(Self::zero(), |acc, x| acc.checked_add(&x))
+ }
+}
+
+
+#[test]
+fn checked_sum_returns_none_instead_of_overflowing() {
+ use crate::identities::One;
+ use crate::iter::num_iter::NumIter;
+
+ macro_rules! test_checked_sum {
+ ($($t:ty)+) => {
+ $(
+ assert_eq!(None::<$t>, [<$t>::MAX, <$t>::one()].iter().checked_sum() );
+ assert_eq!(None::<$t>,IntoIterator::into_iter([<$t>::MAX, <$t>::one()]).checked_sum() );
+ )+
+ };
+ }
+
+ test_checked_sum!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+fn checked_sum_returns_zero_if_empty() {
+ use crate::iter::num_iter::NumIter;
+
+ macro_rules! test_checked_sum {
+ ($($t:ty)+) => {
+ $(
+ assert_eq!(Some(<$t>::zero()), ([] as [$t; 0]).iter().checked_sum() );
+ assert_eq!(Some(<$t>::zero()),IntoIterator::into_iter(([] as [$t; 0])).checked_sum() );
+ )+
+ };
+ }
+
+ test_checked_sum!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+fn checked_sum_returns_correct_sum() {
+ use crate::iter::num_iter::NumIter;
+
+ macro_rules! test_checked_sum {
+ ($($t:ty)+) => {
+ $(
+ assert_eq!(Some(42), ([40,2] as [$t; 2]).iter().checked_sum() );
+ assert_eq!(Some(42),IntoIterator::into_iter(([40,2] as [$t; 2])).checked_sum() );
+ )+
+ };
+ }
+
+ test_checked_sum!(usize u8 u16 u32 u64 isize i8 i16 i32 i64);
+}
+
+#[test]
+fn checked_sum_adds_left_to_right() {
+ use crate::iter::num_iter::NumIter;
+
+ assert_eq!(None::<i8>, [120i8, 8i8, -1i8].iter().checked_sum());
+ assert_eq!(Some(127), [-1i8, 120i8, 8i8].iter().checked_sum());
+}

src/iter/mod.rs

@@ -0,0 +1,3 @@
+pub mod checked_product;
+pub mod checked_sum;
+pub mod num_iter;

src/iter/num_iter.rs

@@ -0,0 +1,50 @@
+use crate::CheckedProduct;
+use crate::CheckedSum;
+
+/// An [`Iterator`] blanket implementation that provides extra adaptors and
+/// methods.
+///
+/// This traits defines methods for summing and multiplying together iterators with overflow checking.
+pub trait NumIter: Iterator {
+ /// Sums the elements of an iterator with overflow checking.
+ ///
+ /// Takes each element, adds them together, and returns the result or None if the addition would overflow.
+ ///
+ /// An empty iterator returns the zero value of the type.
+ ///
+ /// For signed numbers, the order of elements may effect whether the result is `None`.
+ fn checked_sum<A, T: CheckedSum<A>>(self) -> Option<T>
+ where
+ Self: Iterator<Item = A>,
+ Self: Sized;
+
+ /// Iterates over the entire iterator, multiplying all the elements with overflow checking.
+ ///
+ /// Takes each element, multiplies them together, and returns the result or None if the multiplication would overflow.
+ ///
+ /// An empty iterator returns the one value of the type.
+ ///
+ /// For iterators containing zero, the order of elements may effect whether the result is `None`.
+ fn checked_product<A, T: CheckedProduct<A>>(self) -> Option<T>
+ where
+ Self: Iterator<Item = A>,
+ Self: Sized;
+}
+
+impl<I: Iterator> NumIter for I {
+ fn checked_sum<A, T: CheckedSum<A>>(self) -> Option<T>
+ where
+ Self: Iterator<Item = A>,
+ Self: Sized,
+ {
+ CheckedSum::checked_sum(self)
+ }
+
+ fn checked_product<A, T: CheckedProduct<A>>(self) -> Option<T>
+ where
+ Self: Iterator<Item = A>,
+ Self: Sized,
+ {
+ CheckedProduct::checked_product(self)
+ }
+}

src/lib.rs

@@ -35,6 +35,7 @@ pub use crate::float::FloatConst;
 pub use crate::cast::{cast, AsPrimitive, FromPrimitive, NumCast, ToPrimitive};
 pub use crate::identities::{one, zero, One, Zero};
 pub use crate::int::PrimInt;
+pub use crate::iter::{checked_product::CheckedProduct, checked_sum::CheckedSum, num_iter::NumIter};
 pub use crate::ops::checked::{
  CheckedAdd, CheckedDiv, CheckedMul, CheckedNeg, CheckedRem, CheckedShl, CheckedShr, CheckedSub,
 };
@@ -56,6 +57,7 @@ pub mod cast;
 pub mod float;
 pub mod identities;
 pub mod int;
+pub mod iter;
 pub mod ops;
 pub mod pow;
 pub mod real;