Struct RangeTo

pub struct RangeTo<Idx> {
    pub end: Idx,
}

A range only bounded exclusively above (..end).

The RangeTo ..end contains all values with x < end. It cannot serve as an Iterator because it doesn’t have a starting point.

Examples

The ..end syntax is a RangeTo:

assert_eq!((..5), std::ops::RangeTo { end: 5 });

It does not have an IntoIterator implementation, so you can’t use it in a for loop directly. This won’t compile:

// error[E0277]: the trait bound `std::ops::RangeTo<{integer}>:
// std::iter::Iterator` is not satisfied
for i in ..5 {
    // ...
}

When used as a slicing index, RangeTo produces a slice of all array elements before the index indicated by end.

let arr = [0, 1, 2, 3, 4];
assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]);
assert_eq!(arr[ .. 3], [0, 1, 2      ]); // This is a `RangeTo`
assert_eq!(arr[ ..=3], [0, 1, 2, 3   ]);
assert_eq!(arr[1..  ], [   1, 2, 3, 4]);
assert_eq!(arr[1.. 3], [   1, 2      ]);
assert_eq!(arr[1..=3], [   1, 2, 3   ]);

Fields

end: Idx

The upper bound of the range (exclusive).

Implementations

impl<Idx> RangeTo<Idx>

where Idx: PartialOrd,

pub fn contains<U>(&self, item: &U) -> bool

where Idx: PartialOrd<U>, U: PartialOrd<Idx> + ?Sized,

Returns true if item is contained in the range.

Examples

assert!( (..5).contains(&-1_000_000_000));
assert!( (..5).contains(&4));
assert!(!(..5).contains(&5));

assert!( (..1.0).contains(&0.5));
assert!(!(..1.0).contains(&f32::NAN));
assert!(!(..f32::NAN).contains(&0.5));

Trait Implementations

impl<'a, T, O> BitSliceIndex<'a, T, O> for RangeTo<usize>

where O: BitOrder, T: BitStore,

type Immut = &'a BitSlice<T, O>

The output type of immutable access.

type Mut = &'a mut BitSlice<T, O>

The output type of mutable access.

fn get( self, bits: <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Immut, ) -> Option<<RangeTo<usize> as BitSliceIndex<'a, T, O>>::Immut>

Immutably indexes into a bit-slice, returning None if self is out of bounds.

fn get_mut( self, bits: <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Mut, ) -> Option<<RangeTo<usize> as BitSliceIndex<'a, T, O>>::Mut>

Mutably indexes into a bit-slice, returning None if self is out of bounds.

unsafe fn get_unchecked( self, bits: <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Immut, ) -> <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Immut

Immutably indexes into a bit-slice without doing any bounds checking.

unsafe fn get_unchecked_mut( self, bits: <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Mut, ) -> <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Mut

Mutably indexes into a bit-slice without doing any bounds checking.

fn index( self, bits: <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Immut, ) -> <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Immut

Immutably indexes into a bit-slice, panicking if self is out of bounds.

fn index_mut( self, bits: <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Mut, ) -> <RangeTo<usize> as BitSliceIndex<'a, T, O>>::Mut

Mutably indexes into a bit-slice, panicking if self is out of bounds.

impl<Idx> Clone for RangeTo<Idx>

where Idx: Clone,

fn clone(&self) -> RangeTo<Idx>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<Idx> Debug for RangeTo<Idx>

where Idx: Debug,

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de, Idx> Deserialize<'de> for RangeTo<Idx>

where Idx: Deserialize<'de>,

fn deserialize<D>( deserializer: D, ) -> Result<RangeTo<Idx>, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Idx> Hash for RangeTo<Idx>

where Idx: Hash,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, O> Index<RangeTo<usize>> for BitSlice<T, O>

where O: BitOrder, T: BitStore,

type Output = BitSlice<T, O>

The returned type after indexing.

fn index( &self, index: RangeTo<usize>, ) -> &<BitSlice<T, O> as Index<RangeTo<usize>>>::Output

Performs the indexing (container[index]) operation.

impl<T, O> IndexMut<RangeTo<usize>> for BitSlice<T, O>

where O: BitOrder, T: BitStore,

fn index_mut( &mut self, index: RangeTo<usize>, ) -> &mut <BitSlice<T, O> as Index<RangeTo<usize>>>::Output

Performs the mutable indexing (container[index]) operation.

impl<Idx> PartialEq for RangeTo<Idx>

where Idx: PartialEq,

fn eq(&self, other: &RangeTo<Idx>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> RangeBounds<T> for RangeTo<&T>

fn start_bound(&self) -> Bound<&T>

Start index bound.

fn end_bound(&self) -> Bound<&T>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

impl<T> RangeBounds<T> for RangeTo<T>

fn start_bound(&self) -> Bound<&T>

Start index bound.

fn end_bound(&self) -> Bound<&T>

End index bound.

fn contains<U>(&self, item: &U) -> bool

where T: PartialOrd<U>, U: PartialOrd<T> + ?Sized,

Returns true if item is contained in the range.

impl<Idx> Serialize for RangeTo<Idx>

where Idx: Serialize,

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a, T> Slice<RangeTo<usize>> for &'a [T]

fn slice(&self, range: RangeTo<usize>) -> &'a [T]

Slices self according to the range argument

impl<'a> Slice<RangeTo<usize>> for &'a str

fn slice(&self, range: RangeTo<usize>) -> &'a str

Slices self according to the range argument

impl<T> SliceIndex<[T]> for RangeTo<usize>

The methods index and index_mut panic if the end of the range is out of bounds.

type Output = [T]

The output type returned by methods.

fn get(self, slice: &[T]) -> Option<&[T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, if in bounds.

fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a pointer to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable pointer to the output at this location, without performing any bounds checking.

fn index(self, slice: &[T]) -> &[T]

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut(self, slice: &mut [T]) -> &mut [T]

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl SliceIndex<str> for RangeTo<usize>

Implements substring slicing with syntax &self[.. end] or &mut self[.. end].

Returns a slice of the given string from the byte range [0, end). Equivalent to &self[0 .. end] or &mut self[0 .. end].

This operation is O(1).

Prior to 1.20.0, these indexing operations were still supported by direct implementation of Index and IndexMut.

Panics

Panics if end does not point to the starting byte offset of a character (as defined by is_char_boundary), or if end > len.

type Output = str

The output type returned by methods.

fn get( self, slice: &str, ) -> Option<&<RangeTo<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, if in bounds.

fn get_mut( self, slice: &mut str, ) -> Option<&mut <RangeTo<usize> as SliceIndex<str>>::Output>

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, if in bounds.

unsafe fn get_unchecked( self, slice: *const str, ) -> *const <RangeTo<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a pointer to the output at this location, without performing any bounds checking.

unsafe fn get_unchecked_mut( self, slice: *mut str, ) -> *mut <RangeTo<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable pointer to the output at this location, without performing any bounds checking.

fn index(self, slice: &str) -> &<RangeTo<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a shared reference to the output at this location, panicking if out of bounds.

fn index_mut( self, slice: &mut str, ) -> &mut <RangeTo<usize> as SliceIndex<str>>::Output

🔬This is a nightly-only experimental API. (slice_index_methods)

Returns a mutable reference to the output at this location, panicking if out of bounds.

impl<Idx> Copy for RangeTo<Idx>

where Idx: Copy,

impl<Idx> Eq for RangeTo<Idx>

where Idx: Eq,

impl<T> OneSidedRange<T> for RangeTo<T>

where RangeTo<T>: RangeBounds<T>,

impl<Idx> StructuralPartialEq for RangeTo<Idx>