How do I perform iterator computations over iterators of Results without collecting to a temporary vector?

by

Iterator::try_fold provides the framework for what you need, and it’s available since Rust 1.27 (Playground):

fn fold_ok<I, T, E, F>(mut iter: I, f: F) -> Result<Option<T>, E>
where
    I: Iterator<Item = Result<T, E>>,
    T: Ord,
    F: Fn(T, T) -> T,
{
    iter.try_fold(None, |r, i| {
        let i = i?;
        Ok(Some(if let Some(r) = r { f(r, i) } else { i }))
    })
}

fn main() {
    let without_errors = vec![Ok(1), Ok(2), Ok(3)];
    let with_errors = vec![Ok(1), Err("error"), Ok(2)];

    fn doit<'r, T>(name: &str, iter: T)
    where
        T: Iterator<Item = &'r Result<i32, &'static str>> + Clone,
    {
        println!("{}: {:?}", name, fold_ok(iter.cloned(), ::std::cmp::min));
    }

    doit("without errors", without_errors.iter());
    doit("with errors", with_errors.iter());
}

Before that, I think your only option is manually iterating (Playground)

fn fold_ok<I, T, E, F>(mut iter: I, f: F) -> Result<Option<T>, E>
where
    I: Iterator<Item = Result<T, E>>,
    T: Ord,
    F: Fn(T, T) -> T,
{
    let mut result = match iter.next() {
        None => return Ok(None),
        Some(r) => r?,
    };

    for item in iter {
        result = f(result, item?);
    }

    Ok(Some(result))
}

fn main() {
    let without_errors = vec![Ok(1), Ok(2), Ok(3)];
    let with_errors = vec![Ok(1), Err("error"), Ok(2)];

    fn doit<'r, T>(name: &str, iter: T)
    where
        T: Iterator<Item = &'r Result<i32, &'static str>> + Clone,
    {
        println!(
            "{}: {:?}",
            name,
            fold_ok(iter.clone().cloned(), ::std::cmp::min)
        );
    }

    doit("without errors", without_errors.iter());
    doit("with errors", with_errors.iter());
}

More Related Contents:

  1. How do I write an iterator that returns references to itself?
  2. How to implement Iterator and IntoIterator for a simple struct?
  3. How can I add new methods to Iterator?
  4. Are there equivalents to slice::chunks/windows for iterators to loop over pairs, triplets etc?
  5. Iterating over a slice’s values instead of references in Rust?
  6. is it possible to filter on a vector in-place?
  7. How can I zip more than two iterators?
  8. Returning iterator of a Vec in a RefCell
  9. Iterator returning items by reference, lifetime issue
  10. How to write a Rust function that takes an iterator?
  11. How do I return a Filter iterator from a function?
  12. Why do generators not support map()?
  13. How do I get the minimum or maximum value of an iterator containing floating point numbers?
  14. Is there an owned version of String::chars?
  15. What is an idiomatic way to collect an iterator of &T into a collection of Ts?
  16. Using max_by_key on a vector of floats [duplicate]
  17. Writing a generic function that takes an iterable container as parameter in Rust
  18. How do I cope with lazy iterators?
  19. How do I avoid unwrap when converting a vector of Options or Results to only the successful values?
  20. How can I include a module from another file from the same project?
  21. What’s the de-facto way of reading and writing files in Rust 1.x?
  22. Update row values where certain condition is met in pandas
  23. What is an idiomatic way to have shared utility functions for integration tests and benchmarks?
  24. What is the difference between Copy and Clone?
  25. Are non dereferenced iterators past the “one past-the-end” iterator of an array undefined behavior?
  26. Asynchronous iterator Task
  27. How can I store an async function in a struct and call it from a struct instance?
  28. How does Rust’s type inference work across multiple statements?
  29. Handling calls to (potentially) far away ahead-of-time compiled functions from JITed code
  30. How to pass rustc flags to cargo?

Leave a Comment