Rename `Iterators` `invert()` method to something shorter, like `flip()`

[Kimundi]

The docs for it already read as "Flip the direction of the iterator", and it's a shorter name.

The length, at the very least, becomes important if we decide to do something like #9391, because then using invert would become the common way to iterater over values in reverse. Compare:

for c in "abc".chars().invert() {
    // c, b, a
}

for c in "abc".chars().flip() {
    // c, b, a
}

Imo, the meaning also becomes marginally more clear that way.

[dredozubov]

If we do this, we should rename std::iter::Invert to std::iter::Flip. Not sure it is worth doing though. invert sounds pretty straightforward. flip sounds pretty ruby-ish though(nevermind the pun, i actually like the name).

[Kimundi]

Sure, the type names will be adjusted to. I personally think invert is a more confusing name than flip though.

[LeoTestard]

Why not something like .rev() ? It means reverse, which explains pretty well what it does (reverse), it looks like the old name (rev_iter), and it sounds like Caml's List.rev or others, and it is pretty short.

[thestinger]

I would expect reverse to reverse the container in-place, like the current implementation on a DoubleEndedIterator of &mut T does.

[LeoTestard]

I meant a .rev() method on the iterator, not on the container itself. I don't think this would be incompatible with a reverse method on the container that would reverse it in-place, but maybe others may find this confusing.

[Kimundi]

@LeoTestard reverse is a bad name because this method does not reverse the iterator. :P

A double ended iterator has two ends, and iterating with for just takes values from the front.
invert/flip simply swaps those ends, which means iterating over it from the front would now yield values in reverse order, but there is no actual reversing going on.

[lilyball]

I prefer the name invert(). It just seems slightly clearer than flip().

[wting]

I like flip() since it's shorter and the same name / behavior as Haskell's flip().

[kud1ing]

@wting: flip is for function arguments, Haskell's reverse would be the analogon for iterators.

[thestinger]

There's already a reverse and it acts in-place though.

[kud1ing]

A better name for the in-place version could be revert.
"Reverse" could be an adjective/noun ("give me the reverse"), while "revert" is only a verb: "revert this (in-place)".

[kud1ing]

• C++: reverse_iterator, std::list::reverse (in-place),
• Common Lisp: reverse
• Haskell: reverse
• Python: reversed, reverse (in-place),
• Ruby: reverse, reverse! (in-place)

[mankyKitty]

Should it perhaps be something like flip_iter_direction, or flip_iter since it's not reversing the list, it's changing the direction that that iterator is moving on that list.. Or at least as I understand it.

[liigo]

+1 for .rev()