Add try_product and try_sum

`.try_product()` is a more convenient way of writing `.product::<Result<_, _>>()`
`.try_sum()` is a more convenient way of writing `.sum::<Result<_, _>>()`

src/lib.rs

@@ -52,10 +52,8 @@ extern crate alloc;
 
 #[cfg(feature = "use_alloc")]
 use alloc::{string::String, vec::Vec};
-
-pub use either::Either;
-
 use core::borrow::Borrow;
+pub use either::Either;
 use std::cmp::Ordering;
 #[cfg(feature = "use_std")]
 use std::collections::HashMap;
@@ -144,8 +142,7 @@ pub mod traits {
 
 pub use crate::concat_impl::concat;
 pub use crate::cons_tuples_impl::cons_tuples;
-pub use crate::diff::diff_with;
-pub use crate::diff::Diff;
+pub use crate::diff::{diff_with, Diff};
 #[cfg(feature = "use_alloc")]
 pub use crate::kmerge_impl::kmerge_by;
 pub use crate::minmax::MinMaxResult;
@@ -2195,7 +2192,7 @@ pub trait Itertools: Iterator {
         self.collect()
     }
 
-    /// `.try_collect()` is more convenient way of writing
+    /// `.try_collect()` is a more convenient way of writing
     /// `.collect::<Result<_, _>>()`
     ///
     /// # Example
@@ -2223,6 +2220,56 @@ pub trait Itertools: Iterator {
         self.collect()
     }
 
+    /// `.product_ok()` is a more convenient way of writing `.product::<Result<_, _>>()`
+    ///
+    /// **Panics** when a primitive integer type is returned and the computation
+    /// overflows, and debug assertions are enabled.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use itertools::Itertools;
+    /// use std::str::FromStr;
+    ///
+    /// fn main() -> Result<(), std::num::ParseIntError> {
+    ///     let product: u64 = ["1", "2", "3"].iter().map(|x| u64::from_str(x)).product_ok()?;
+    ///     assert_eq!(product, 6);
+    ///     Ok(())
+    /// }
+    /// ```
+    fn product_ok<T, U, E>(self) -> Result<U, E>
+    where
+        Self: Sized + Iterator<Item = Result<T, E>>,
+        Result<U, E>: std::iter::Product<Result<T, E>>,
+    {
+        self.product()
+    }
+
+    /// `.sum_ok()` is a more convenient way of writing `.sum::<Result<_, _>>()`
+    ///
+    /// **Panics** when a primitive integer type is returned and the computation
+    /// overflows, and debug assertions are enabled.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use itertools::Itertools;
+    /// use std::str::FromStr;
+    ///
+    /// fn main() -> Result<(), std::num::ParseIntError> {
+    ///     let sum: u64 = ["1", "2", "3"].iter().map(|x| u64::from_str(x)).sum_ok()?;
+    ///     assert_eq!(sum, 6);
+    ///     Ok(())
+    /// }
+    /// ```
+    fn sum_ok<T, U, E>(self) -> Result<U, E>
+    where
+        Self: Sized + Iterator<Item = Result<T, E>>,
+        Result<U, E>: std::iter::Sum<Result<T, E>>,
+    {
+        self.sum()
+    }
+
     /// Assign to each reference in `self` from the `from` iterator,
     /// stopping at the shortest of the two iterators.
     ///