From TFA, on combinators vs. loops:
items.iter().enumerate().filter(|(_, i)| cond(i)).map(|(idx, i)| Pointer::idx(i, path, idx)).collect()
while (i < cursors.len) {
if (actual_index < arr.items.len) { cursors[i] = .{...}; i += 1; }
else iteration.remove(i);
}
.len doesn't work on a list (because it might mislead you about the efficiency of the operation if it did exist), so it's better to use iterators - so then you can change the underlying type without changing your code.
But then, saying while "let Some(item) = iter.next()" everytime is tedious, so they give you .iter() - for any type that is efficiently iterable.
Nothing stopping you using a manual loop that you need to update if you change the container type.
items is already an iteratible so you can do direct .filter on it as well
tl;dr if the code looks ugly you're probably not taking advantage of a language feature that allows it to look pretty.
This is in fact more readable, thank you.
I still don’t know that I find it more intuitive or readable than the simple loop, but it’s much less awful than before.
I am sure there's a way to filter directly on cond variable and collect isn't needed most of the time since iterators are way more useful in general (unless you want to print that data)
I know this is possible, but you would have to consult some rust wizard for this.