How do I cope with lazy iterators?

Question

I\'m trying to sort an array with a map() over an iterator.

struct A {
    b: Vec,
}

#[derive(PartialEq, Eq, PartialOrd, Ord)]
struct          


        

Answer 1

I use for_each. According to the doc:

It is equivalent to using a for loop on the iterator, although break and continue are not possible from a closure. It's generally more idiomatic to use a for loop, but for_each may be more legible when processing items at the end of longer iterator chains. In some cases for_each may also be faster than a loop, because it will use internal iteration on adaptors like Chain.

Answer 2

I don't understand why this variation with iter_mut() works fine:

a.b.iter_mut().find(|b| b == b).map(|b| b.c.sort());

It works because find is not lazy; it's an iterator consumer. It returns an Option not an Iterator. This might be why it is confusing you, because Option also has a map method, which is what you are using here.

---

As others have said, map is intended for transforming data, without modifying it and without any other side-effects. If you really want to use map, you can map over the collection and assign it back:

fn main() {
    let mut a = A { b: Vec::new() };
    let mut b = B { c: vec![5, 2, 3] };
    a.b.push(b);

    a.b =
        a.b.into_iter()
            .map(|mut b| {
                b.c.sort();
                b
            })
            .collect();
}

Note that vector's sort method returns (), so you have to explicitly return the sorted vector from the mapping function.

Answer 3

As the book you linked to says:

If you are trying to execute a closure on an iterator for its side effects, use for instead.

That way it works, and it's much clearer to anyone reading the code. You should use map when you want to transform a vector to a different one.