Struct RangeInclusive

struct RangeInclusive<Idx> { ... }

A range bounded inclusively below and above (start..=end).

The RangeInclusive start..=end contains all values with x >= start and x <= end. It is empty unless start <= end.

This iterator is fused, but the specific values of start and end after iteration has finished are unspecified other than that .is_empty() will return true once no more values will be produced.

Examples

The start..=end syntax is a RangeInclusive:

assert_eq!((3..=5), std::ops::RangeInclusive::new(3, 5));
assert_eq!(3 + 4 + 5, (3..=5).sum());

let arr = [0, 1, 2, 3, 4];
assert_eq!(arr[ ..  ], [0, 1, 2, 3, 4]);
assert_eq!(arr[ .. 3], [0, 1, 2      ]);
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   ]); // This is a `RangeInclusive`

Implementations

impl<Idx> RangeInclusive<Idx>

const fn new(start: Idx, end: Idx) -> Self

Creates a new inclusive range. Equivalent to writing start..=end.

Examples

use std::ops::RangeInclusive;

assert_eq!(3..=5, RangeInclusive::new(3, 5));

const fn start(self: &Self) -> &Idx

Returns the lower bound of the range (inclusive).

When using an inclusive range for iteration, the values of start() and end() are unspecified after the iteration ended. To determine whether the inclusive range is empty, use the is_empty() method instead of comparing start() > end().

Note: the value returned by this method is unspecified after the range has been iterated to exhaustion.

Examples

assert_eq!((3..=5).start(), &3);

const fn end(self: &Self) -> &Idx

Returns the upper bound of the range (inclusive).

When using an inclusive range for iteration, the values of start() and end() are unspecified after the iteration ended. To determine whether the inclusive range is empty, use the is_empty() method instead of comparing start() > end().

Note: the value returned by this method is unspecified after the range has been iterated to exhaustion.

Examples

assert_eq!((3..=5).end(), &5);

const fn into_inner(self: Self) -> (Idx, Idx)

Destructures the RangeInclusive into (lower bound, upper (inclusive) bound).

Note: the value returned by this method is unspecified after the range has been iterated to exhaustion.

Examples

assert_eq!((3..=5).into_inner(), (3, 5));

impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx>

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

Returns true if item is contained in the range.

Examples

assert!(!(3..=5).contains(&2));
assert!( (3..=5).contains(&3));
assert!( (3..=5).contains(&4));
assert!( (3..=5).contains(&5));
assert!(!(3..=5).contains(&6));

assert!( (3..=3).contains(&3));
assert!(!(3..=2).contains(&3));

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

This method always returns false after iteration has finished:

let mut r = 3..=5;
assert!(r.contains(&3) && r.contains(&5));
for _ in r.by_ref() {}
// Precise field values are unspecified here
assert!(!r.contains(&3) && !r.contains(&5));

const fn is_empty(self: &Self) -> bool
where
    Idx: ~const PartialOrd

Returns true if the range contains no items.

Examples

assert!(!(3..=5).is_empty());
assert!(!(3..=3).is_empty());
assert!( (3..=2).is_empty());

The range is empty if either side is incomparable:

assert!(!(3.0..=5.0).is_empty());
assert!( (3.0..=f32::NAN).is_empty());
assert!( (f32::NAN..=5.0).is_empty());

This method returns true after iteration has finished:

let mut r = 3..=5;
for _ in r.by_ref() {}
// Precise field values are unspecified here
assert!(r.is_empty());

impl ExactSizeIterator for RangeInclusive<i16>

impl ExactSizeIterator for RangeInclusive<i8>

impl ExactSizeIterator for RangeInclusive<u16>

impl ExactSizeIterator for RangeInclusive<u8>

impl GetDisjointMutIndex for RangeInclusive<usize>

fn is_in_bounds(self: &Self, len: usize) -> bool
fn is_overlapping(self: &Self, other: &Self) -> bool

impl SliceIndex for RangeInclusive<usize>

fn get(self: Self, slice: &ByteStr) -> Option<&<Self as >::Output>
fn get_mut(self: Self, slice: &mut ByteStr) -> Option<&mut <Self as >::Output>
unsafe fn get_unchecked(self: Self, slice: *const ByteStr) -> *const <Self as >::Output
unsafe fn get_unchecked_mut(self: Self, slice: *mut ByteStr) -> *mut <Self as >::Output
fn index(self: Self, slice: &ByteStr) -> &<Self as >::Output
fn index_mut(self: Self, slice: &mut ByteStr) -> &mut <Self as >::Output

impl SliceIndex for RangeInclusive<usize>

fn get(self: Self, slice: &str) -> Option<&<Self as >::Output>
fn get_mut(self: Self, slice: &mut str) -> Option<&mut <Self as >::Output>
unsafe fn get_unchecked(self: Self, slice: *const str) -> *const <Self as >::Output
unsafe fn get_unchecked_mut(self: Self, slice: *mut str) -> *mut <Self as >::Output
fn index(self: Self, slice: &str) -> &<Self as >::Output
fn index_mut(self: Self, slice: &mut str) -> &mut <Self as >::Output

impl<A: Step> DoubleEndedIterator for RangeInclusive<A>

fn next_back(self: &mut Self) -> Option<A>
fn nth_back(self: &mut Self, n: usize) -> Option<A>
fn try_rfold<B, F, R>(self: &mut Self, init: B, f: F) -> R
where
    Self: Sized,
    F: FnMut(B, <Self as >::Item) -> R,
    R: Try<Output = B>
fn rfold<AAA, FFF>(self: Self, init: AAA, fold: FFF) -> AAA
where
    FFF: FnMut(AAA, <Self as >::Item) -> AAA

impl<A: Step> FusedIterator for RangeInclusive<A>

impl<A: Step> Iterator for RangeInclusive<A>

fn next(self: &mut Self) -> Option<A>
fn size_hint(self: &Self) -> (usize, Option<usize>)
fn count(self: Self) -> usize
fn nth(self: &mut Self, n: usize) -> Option<A>
fn try_fold<B, F, R>(self: &mut Self, init: B, f: F) -> R
where
    Self: Sized,
    F: FnMut(B, <Self as >::Item) -> R,
    R: Try<Output = B>
fn fold<AAA, FFF>(self: Self, init: AAA, fold: FFF) -> AAA
where
    FFF: FnMut(AAA, <Self as >::Item) -> AAA
fn last(self: Self) -> Option<A>
fn min(self: Self) -> Option<A>
where
    A: Ord
fn max(self: Self) -> Option<A>
where
    A: Ord
fn is_sorted(self: Self) -> bool

impl<A: TrustedStep> TrustedLen for RangeInclusive<A>

impl<I> IntoIterator for RangeInclusive<Idx>

fn into_iter(self: Self) -> I

impl<Idx> Freeze for RangeInclusive<Idx>

impl<Idx> RefUnwindSafe for RangeInclusive<Idx>

impl<Idx> Send for RangeInclusive<Idx>

impl<Idx> StructuralPartialEq for RangeInclusive<Idx>

impl<Idx> Sync for RangeInclusive<Idx>

impl<Idx> Unpin for RangeInclusive<Idx>

impl<Idx> UnsafeUnpin for RangeInclusive<Idx>

impl<Idx> UnwindSafe for RangeInclusive<Idx>

impl<Idx: $crate::clone::Clone> Clone for RangeInclusive<Idx>

fn clone(self: &Self) -> RangeInclusive<Idx>

impl<Idx: $crate::hash::Hash> Hash for RangeInclusive<Idx>

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

impl<Idx: fmt::Debug> Debug for RangeInclusive<Idx>

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

impl<Idx: ~const $crate::cmp::Eq> Eq for RangeInclusive<Idx>

impl<Idx: ~const $crate::cmp::PartialEq> PartialEq for RangeInclusive<Idx>

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

impl<T> Any for RangeInclusive<Idx>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for RangeInclusive<Idx>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for RangeInclusive<Idx>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for RangeInclusive<Idx>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for RangeInclusive<Idx>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> From for RangeInclusive<T>

fn from(value: RangeInclusive<T>) -> Self

impl<T> IntoBounds for RangeInclusive<T>

fn into_bounds(self: Self) -> (Bound<T>, Bound<T>)

impl<T> RangeBounds for RangeInclusive<&T>

fn start_bound(self: &Self) -> Bound<&T>
fn end_bound(self: &Self) -> Bound<&T>

impl<T> RangeBounds for RangeInclusive<T>

fn start_bound(self: &Self) -> Bound<&T>
fn end_bound(self: &Self) -> Bound<&T>

impl<T> SliceIndex for RangeInclusive<usize>

fn get(self: Self, slice: &[T]) -> Option<&[T]>
fn get_mut(self: Self, slice: &mut [T]) -> Option<&mut [T]>
unsafe fn get_unchecked(self: Self, slice: *const [T]) -> *const [T]
unsafe fn get_unchecked_mut(self: Self, slice: *mut [T]) -> *mut [T]
fn index(self: Self, slice: &[T]) -> &[T]
fn index_mut(self: Self, slice: &mut [T]) -> &mut [T]

impl<T, U> Into for RangeInclusive<Idx>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for RangeInclusive<Idx>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for RangeInclusive<Idx>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>