From the first few graphs:

> Rust has a nice pretty syntax for iterating:

    for x in &mut something {
        *x = (*x) * 2;
    }

> EXCEPT when you need to do anything else to the iterator, then its ugly:

    for (i, x) in something.iter_mut().filter(|| {...}).enumerate() {
        *x = (*x) * i
    }

This is just so goofy. Who writes Rust like this? Wouldn't everyone write:

    something
        .iter_mut()
        .filter(|| {...})
        .enumerate()
        .for_each(|(i, x)|) {
            *x = (*x) * i
        });

> There should be one -- and preferably only one --obvious way to do it.

Overhead-wise, you can't expect everyone to take to the iterator model right away. Sometimes you want a for loop, or you want a for loop for right now.

I think Rust being multi-paradigm is a strength, with the understanding that the preferred approach/model is the more functional, more immutable iterator model for 95% of your use cases.

> Again, the absolute lack of composability is astounding. Whats the point of even having iterator methods if you can't use them for real world usecases, where code is regularly fallable, so you need to return a Result.

You can, you just haven't figured out how yet. This is frustrating, but, gosh, you'll learn how sooner or later.

    let y: Result<Vec<_>> = iterator.map(|x| {
        x.some_fallible_method()
    }).collect();