Indexable exhaustive types

[kpreid]

Add a trait & derive for indexable types. Something like:

trait Indexable: Exhaust {
    /// Number of distinct values of this type.
    /// Equivalent to `Self::exhaust().len()`, but is a constant.
    const VALUE_COUNT: usize;

    /// Returns the position within `Self::exhaust()` that `value` may be found.
    /// Equivalent to `Self::exhaust().position(value).unwrap()`; note that a correct implementation cannot panic.
    fn to_index(value: &Self) -> usize;

    /// Equivalent to `Self::exhaust().nth(index).unwrap()`.
    /// Panics if `index >= Self::VALUE_COUNT`
    fn from_index(index: usize) -> self;
}

This allows building fixed-size, exhaustive mapping data structures like enum-map, but with the nestability that exhaust::Exhaust supports.

Exhaust iterators for this type should also override position() and nth() to be O(1), but we do not want this to be the sole interface because it may be undesirable to allocate the iterator first, and because they are tedious to use and have an unwrap().

[kpreid]

Further use cases:

• Randomly selecting an arbitrary value, using a random index integer provided by rand or arbitrary. We should not add dependencies for this purpose, but we should make sure it's easy and provide examples of doing so.
• Obtaining the “next” and “previous” value by to_index(), incrementing or decrementing, then from_index(). Or, producing an iterator starting or ending at a specific value.
• The override of nth() would provide efficient T::exhaust().skip(n) for free.