Add SliceIndex impl for pair of Bounds

[clarfonthey]

This effectively allows using the RangeBounds trait to index slices, since there aren't any existing ranges that would work otherwise with a Bound::Excluded start. This basically uses the same strategy as RangeInclusive and just fails if you're trying to do a range starting at exclusive usize::MAX, since that effectively would never work.

Would require FCP but considering how pairs of bounds are allowed for RangeBounds, it seems reasonable to allow them for slices too.

(Working on adding tests.)

[rust-highfive]

r? @m-ou-se

(rust-highfive has picked a reviewer for you, use r? to override)

[dylni]

assert_len can make this simpler:

Suggested change

	let start = match self.0 {
	ops::Bound::Unbounded => 0,
	ops::Bound::Included(start) => start,
	ops::Bound::Excluded(start) if start == usize::MAX => slice_start_index_overflow_fail(),
	ops::Bound::Excluded(start) => start + 1,
	};
	let end = match self.1 {
	ops::Bound::Unbounded => slice.len(),
	ops::Bound::Included(end) if end == usize::MAX => slice_end_index_overflow_fail(),
	ops::Bound::Included(end) => end + 1,
	ops::Bound::Excluded(end) => end,
	};
	(start..end).index(slice)
	unsafe {
	slice.get_unchecked(self.assert_len(slice.len()))
	}

[clarfonthey]

I tried looking for a method like this and apparently couldn't find one, huh.

[dylni]

Don't worry. I only know about it because I implemented it.

[dylni]

It can be used here too:

Suggested change

	let start = match self.0 {
	ops::Bound::Unbounded => 0,
	ops::Bound::Included(start) => start,
	ops::Bound::Excluded(start) if start == usize::MAX => slice_start_index_overflow_fail(),
	ops::Bound::Excluded(start) => start + 1,
	};
	let end = match self.1 {
	ops::Bound::Unbounded => slice.len(),
	ops::Bound::Included(end) if end == usize::MAX => slice_end_index_overflow_fail(),
	ops::Bound::Included(end) => end + 1,
	ops::Bound::Excluded(end) => end,
	};
	(start..end).index_mut(slice)
	unsafe {
	slice.get_unchecked_mut(self.assert_len(slice.len()))
	}

[RalfJung]

I am not sure if it is a good idea to implicitly overflow in get_unchecked (and get_mutunchecked`). The "unchecked" refers to the slice bounds, how is the caller supposed to know that they also need to guard against overflow?

[clarfonthey]

So I used the existing code in RangeInclusive for precedent as that also doesn't guard against overflow. I'm fine just doing a saturated_add instead though.

[RalfJung]

Hm, that's a fair point. But I still feel like this choice (either way) should be documented somewhere.

[RalfJung]

This effectively allows using the RangeBounds trait to index slices, since there aren't any existing ranges that would work otherwise with a Bound::Excluded start.

So, could you give some examples for how you imagine this could be used? The PR has no testcase at all so this is a bit hard to see.

[dylni]

I just found this PR, which should add the same impls. It has an active FCP, and it has the same question of what its use case would be.

[m-ou-se]

I just found this PR, which should add the same impls. It has an active FCP, and it has the same question of what its use case would be.

Closing this as a duplicate of #77704. Feel free to join the discussion there. Thanks!