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 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.