Add CollectVecResult, release 1.1.0

Author: Expurple

CHANGELOG.md

@@ -9,6 +9,12 @@ and this project adheres to
 
 ## \[Unreleased]
 
+## \[1.1.0] - 2024-04-08
+
+### Added
+
+- Iterator trait `CollectVecResult` with method `collect_vec_result`.
+
 ## \[1.0.0] - 2024-04-08
 
 Initial release.

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "multiple_errors"
-version = "1.0.0"
+version = "1.1.0"
 edition = "2021"
 authors = ["Dmitrii Aleksandrov <adk230@yandex.ru>"]
 documentation = "https://docs.rs/multiple_errors/"

README.md

@@ -24,22 +24,22 @@ pull request if you need this.
 ## Example
 
 ```rust
-use multiple_errors::{fail_all_vec, return_multiple_errors};
+use multiple_errors::{fail_all_vec, return_multiple_errors, CollectVecResult};
 use multiple_errors::testing_prelude::*;
-        
-// fail_all_vec:
+
+assert_eq!(
+    [Err(ErrA), Ok(A), Err(ErrA)].into_iter().collect_vec_result(),
+    // Collected all errors, not just the first one
+    Err(vec![ErrA, ErrA])
+);
 
 let err = fail_all_vec(
     vec![Ok(A), Err(ErrA), Ok(A)],
     |res| res.err().map(HighLevelErr::from).unwrap_or(HighLevelErr::B(ErrB))
 );
+// Same length as the original, each element turned into an error.
 assert_eq!(err, Err(vec![ErrB.into(), ErrA.into(), ErrB.into()]));
 
-let ok = fail_all_vec(vec![Ok(A), Ok(A)], |_: Result<_, ErrA>| ErrC);
-assert_eq!(ok, Ok(vec![A, A]));
-
-// return_multiple_errors:
-
 fn a_b_c() -> Result<(A, B, C), Vec<HighLevelErr>> {
     return_multiple_errors!(
         let mut errors: Vec<HighLevelErr> = vec![];
@@ -74,7 +74,11 @@ fn a_b_c() -> Result<(A, B, C), Vec<HighLevelErr>> {
     > Partition a sequence of Results into one list of all the Ok elements and
     > another list of all the Err elements.
 
-    This is often useful, use `itertools` for this.
+    If you need both lists, just use
+    [itertools](https://github.com/rust-itertools/itertools). If you discard
+    `Ok`s in case of errors, you can use
+    `CollectVecResult::collect_vec_result()` that returns
+    `Result<Vec<T>, Vec<E>>`. It's more precise and efficient.
 
 ## License
 

src/collect.rs

@@ -0,0 +1,50 @@
+/// Provides `collect_vec_result() -> Result<Vec<T>, Vec<E>>`
+pub trait CollectVecResult: Iterator<Item = Result<Self::T, Self::E>> {
+    type T;
+    type E;
+    /// Like standard `Iterator::collect::<Result<Vec<T>, E>>`, but all errors
+    /// instead of just the first one.
+    ///
+    /// Doesn't short-circuit, always exhausts the iterator.
+    ///
+    /// ## Examples
+    ///
+    /// ```rust
+    /// # use multiple_errors::testing_prelude::*;
+    /// # use multiple_errors::CollectVecResult;
+    /// #
+    /// assert_eq!(
+    ///     [Err(ErrA), Ok(A), Err(ErrA)].into_iter().collect_vec_result(),
+    ///     // Collected all errors, not just the first one
+    ///     Err(vec![ErrA, ErrA])
+    /// );
+    /// ```
+    fn collect_vec_result(self) -> Result<Vec<Self::T>, Vec<Self::E>>;
+}
+
+impl<I, T, E> CollectVecResult for I
+where
+    I: Iterator<Item = Result<T, E>>,
+{
+    type T = T;
+    type E = E;
+    fn collect_vec_result(self) -> Result<Vec<Self::T>, Vec<Self::E>> {
+        let mut oks = vec![];
+        let mut errs = vec![];
+        for elem in self {
+            match elem {
+                Err(err) => errs.push(err),
+                Ok(ok) => {
+                    // Don't grow `oks` if we already know that we'll discard it.
+                    if errs.is_empty() {
+                        oks.push(ok)
+                    }
+                }
+            }
+        }
+        match errs.as_slice() {
+            [] => Ok(oks),
+            [_, ..] => Err(errs),
+        }
+    }
+}

src/fail_all.rs

@@ -34,6 +34,7 @@
 ///     [Ok(A), Err(ErrA), Ok(A)],
 ///     |res| res.err().map(HighLevelErr::from).unwrap_or(HighLevelErr::B(ErrB))
 /// );
+/// // Each element turned into an error.
 /// assert_eq!(err, Err([ErrB.into(), ErrA.into(), ErrB.into()]));
 /// ```
 pub fn fail_all<I, T, E1, E2, F>(
@@ -72,10 +73,11 @@ where
 ///     vec![Ok(A), Err(ErrA), Ok(A)],
 ///     |res| res.err().map(HighLevelErr::from).unwrap_or(HighLevelErr::B(ErrB))
 /// );
+/// // Same length as the original, each element turned into an error.
 /// assert_eq!(err, Err(vec![ErrB.into(), ErrA.into(), ErrB.into()]));
-///
-/// let ok = fail_all_vec(vec![Ok(A), Ok(A)], |_: Result<_, ErrA>| ErrC);
-/// assert_eq!(ok, Ok(vec![A, A]));
+/// #
+/// # let ok = fail_all_vec(vec![Ok(A), Ok(A)], |_: Result<_, ErrA>| ErrC);
+/// # assert_eq!(ok, Ok(vec![A, A]));
 /// ```
 pub fn fail_all_vec<T, E1, E2, F>(results: Vec<Result<T, E1>>, f: F) -> Result<Vec<T>, Vec<E2>>
 where

src/lib.rs

@@ -3,6 +3,9 @@
 #[doc(hidden)]
 pub mod testing_prelude;
 
+mod collect;
+pub use collect::CollectVecResult;
+
 mod fail_all;
 pub use fail_all::{fail_all, fail_all_vec};