Struct nom::lib::std::ops::RangeTo

#[lang = "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<Idx>, 

pub fn contains<U>(&self, item: &U) -> bool where
    U: PartialOrd<Idx> + ?Sized,
    Idx: PartialOrd<U>, 

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, O, T> BitSliceIndex<'a, O, T> for RangeTo<usize> where
    O: 'a + BitOrder,
    T: 'a + BitStore, 

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

The output type for immutable functions.

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

The output type for mutable functions.

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

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

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

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

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

Returns a shared reference to the output at this location, without performing any bounds checking. Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

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

Returns a mutable reference to the output at this location, without performing any bounds checking. Calling this method with an out-of-bounds index is undefined behavior even if the resulting reference is not used.

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

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

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

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

impl<Idx> Clone for RangeTo<Idx> where
    Idx: Clone, 

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Idx> Copy for RangeTo<Idx> where
    Idx: Copy, 

impl<Idx> Debug for RangeTo<Idx> where
    Idx: Debug, 

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

Formats the value using the given formatter.

impl<Idx> Eq for RangeTo<Idx> where
    Idx: Eq, 

impl<Idx> Hash for RangeTo<Idx> where
    Idx: Hash, 

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

Feeds this value into the given Hasher.

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

Feeds a slice of this type into the given Hasher.

impl Index<RangeTo<usize>> for String

type Output = str

The returned type after indexing.

pub fn index(&self, index: RangeTo<usize>) -> &str

Performs the indexing (container[index]) operation.

impl<O, T> Index<RangeTo<usize>> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

type Output = BitSlice<O, T>

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl IndexMut<RangeTo<usize>> for String

pub fn index_mut(&mut self, index: RangeTo<usize>) -> &mut str

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

impl<O, T> IndexMut<RangeTo<usize>> for BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

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

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

impl<Idx> PartialEq<RangeTo<Idx>> for RangeTo<Idx> where
    Idx: PartialEq<Idx>, 

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

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

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

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

Start index bound.

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

End index bound.

pub fn assert_len(self, len: usize) -> Range<usize> where
    Self: RangeBounds<usize>, 

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

Performs bounds-checking of this range.

pub 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>

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

Start index bound.

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

End index bound.

pub fn assert_len(self, len: usize) -> Range<usize> where
    Self: RangeBounds<usize>, 

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

Performs bounds-checking of this range.

pub 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<'a> Slice<RangeTo<usize>> for &'a str

fn slice(&self, range: RangeTo<usize>) -> Self

Slices self according to the range argument

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

fn slice(&self, range: RangeTo<usize>) -> Self

Slices self according to the range argument

impl<'a, O, T> Slice<RangeTo<usize>> for &'a BitSlice<O, T> where
    O: BitOrder,
    T: BitStore, 

fn slice(&self, range: RangeTo<usize>) -> Self

Slices self according to the range argument

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

type Output = [T]

The output type returned by methods.

pub 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.

pub 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.

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

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

Returns a shared reference to the output at this location, without performing any bounds checking. Calling this method with an out-of-bounds index or a dangling slice pointer is undefined behavior even if the resulting reference is not used.

pub unsafe fn get_unchecked_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, without performing any bounds checking. Calling this method with an out-of-bounds index or a dangling slice pointer is undefined behavior even if the resulting reference is not used.

pub 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.

pub 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.

pub 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.

pub 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.

pub 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 shared reference to the output at this location, without performing any bounds checking. Calling this method with an out-of-bounds index or a dangling slice pointer is undefined behavior even if the resulting reference is not used.

pub 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 reference to the output at this location, without performing any bounds checking. Calling this method with an out-of-bounds index or a dangling slice pointer is undefined behavior even if the resulting reference is not used.

pub 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.

pub 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> StructuralEq for RangeTo<Idx>

impl<Idx> StructuralPartialEq for RangeTo<Idx>