ExactSize: Reversible enumerate and generic rposition()

[bluss]

The message of the first commit explains (edited for changed trait name):

The trait ExactSize is introduced to solve a few small niggles:

• We can't reverse (.invert()) an enumeration iterator
• for a vector, we have v.iter().position(f) but v.rposition(f).
• We can't reverse Zip even if both iterators are from vectors

ExactSize is an empty trait that is intended to indicate that an
iterator, for example VecIterator, knows its exact finite size and
reports it correctly using .size_hint(). Only adaptors that preserve
this at all times, can expose this trait further. (Where here we say
finite for fitting in uint).

---

It may seem complicated just to solve these small "niggles",
(It's really the reversible enumerate case that's the most interesting)
but only a few core iterators need to implement this trait.

While we gain more capabilities generically for some iterators,
it becomes a tad more complicated to figure out if a type has
the right trait impls for it.

[huonw]

Is there any particular reason the new traits don't inherit from Iterator (or DoubleEndedIterator, etc)?

[bluss]

thanks for the comments.

I think an explicit non-default fn exact_size is a good idea. But, it would leave another place where the iterator declares its size. There is RandomAccessIterator::indexable() too already, but it is not useful for this problem, because it may be defined even for infinite (or larger than uint) iterators.

[huonw]

It would be neat if we could have something like:

trait ExactSizeHint: Iterator {
    #[test]
    fn test_exact_size_hint() {
        let it = make_a_self(); // the hard part
        assert!(match it.size_hint() {
            (n, Some(m)) => n == m,
            _ => false
        })
    }
}

so the test would be automatically included for every implementation of the trait.... but, it's currently not possible to implement make_a_self.