Implement the Iterator trait for RangeTo for consistency

[aochagavia]

Currently, Range and RangeFrom implement the Iterator trait, butRangeTo doesn't.

This leads to the following situation:

// Works.
for _ in 0..10 {

}

// Works. Note that this is an infinite loop
for _ in 0.. {

}

// Doesn't work. RangeTo does not implement the Iterator trait
for _ in ..10 {

}

The problem of RangeTo is that there is no way to know which value is considered to be zero (the old Zero trait was removed a couple of months ago, so we cannot add it as a bound of the ).

A first solution that comes to my mind is something like

// This can be trivially implemented for the integer types
trait Enumerable : Step {
    fn min() -> Self;
    fn zero() -> Self;
    fn max() -> Self;
}

impl<Idx: Clone + Enumerable> Iterator for RangeFrom<Idx> {
    type Item = Idx;

    #[inline]
    fn next(&mut self) -> Option<Idx> {
        let zero: Idx = Enumerable::zero();
        // etc
    }
}

However, this may require an RFC and it is possible that someone has a simpler solution (I hope it).

[Diggsey]

But RangeTo doesn't represent a range that starts from zero, it's a range that has no lower bound, and therefore cannot be iterated in a forward direction.

One possibility is to extract the method "next_back" from "DoubleEndedIterator" into a separate trait: "ReverseIterator" or "BackIterator", and "DoubleEndedIterator" is then equivalent to "Iterator + BackIterator".

Now, "Range" can implement "DoubleEndedIterator", "RangeFrom" can implement "Iterator", and "RangeTo" can implement "BackIterator". Finally, the "Rev" function is extended to work on all iterators, such that Rev(Iterator) => BackIterator, Rev(BackIterator) => Iterator, and Rev(DoubleEndedIterator) => DoubleEndedIterator.

This would allow iteration of RangeTo but only in the reverse direction.

[aochagavia]

I had assumed that RangeTo started from zero, because xs[..2] is the same as xs[0..2]. If it is not the case, then I guess this issue doesn't make too much sense.

[fiveseven-lambda]

I would like to re-open the discussion on splitting the current DoubleEndedIterator trait into two separate traits: one for forward iteration (Iterator) and one for reverse iteration (ReverseIterator).

The discussion above aimed to allow types like RangeTo and RangeToInclusive to implement reverse iteration. This change would enable us to write expressions like:

(..=n).rev()

and it intuitively represents an infinite descending iterator starting from n, rather than the finite one.

Currently, to achieve an infinite reverse iterator (i.e., a descending sequence starting from n), we have to resort to workarounds such as:

https://users.rust-lang.org/t/rev-method-on-rangeto/74101/2 (by Frank Steffahn)

std::iter::repeat_with({
    let mut i = n;
    move || (i, i -= 1).0
})

Alternative approaches like:

• (0..).map(|i| n - i)
  – may suffer from overflow issues.

• std::iter::successors(Some(n), |&n| Some(n - 1))
  – does not properly advertise its infinite nature through its size_hint and TrustedLen implementation.

For context, consider the implementation of RangeFrom:

rust/library/core/src/iter/range.rs

Lines 1010 to 1035 in ce36a96

	#[stable(feature = "rust1", since = "1.0.0")]
	impl<A: Step> Iterator for ops::RangeFrom<A> {
	type Item = A;
	#[inline]
	fn next(&mut self) -> Option<A> {
	let n = Step::forward(self.start.clone(), 1);
	Some(mem::replace(&mut self.start, n))
	}
	#[inline]
	fn size_hint(&self) -> (usize, Option<usize>) {
	(usize::MAX, None)
	}
	#[inline]
	fn nth(&mut self, n: usize) -> Option<A> {
	let plus_n = Step::forward(self.start.clone(), n);
	self.start = Step::forward(plus_n.clone(), 1);
	Some(plus_n)
	}
	}
	// Safety: See above implementation for `ops::Range<A>`
	#[unstable(feature = "trusted_len", issue = "37572")]
	unsafe impl<A: TrustedStep> TrustedLen for ops::RangeFrom<A> {}

This implementation correctly signals the iterator's infinite nature.