Struct RangeInclusive

pub struct RangeInclusive<Idx> { pub(crate) start: Idx, pub(crate) end: Idx, pub(crate) exhausted: bool }

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`

Fields

start: Idx
end: Idx
exhausted: bool

Implementations

impl RangeInclusive<usize>

const fn into_slice_range(self) -> Range<usize>

Converts to an exclusive Range for SliceIndex implementations. The caller is responsible for dealing with end == usize::MAX.

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) -> &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) -> &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) -> (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, 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) -> 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());

Trait Implementations

impl ExactSizeIterator for RangeInclusive<NonZero<u16>>

impl ExactSizeIterator for RangeInclusive<NonZero<u8>>

impl ExactSizeIterator for RangeInclusive<NonZero<usize>>

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, len: usize) -> bool
fn is_overlapping(&self, other: &Self) -> bool

impl SliceIndex<ByteStr> for RangeInclusive<usize>

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

impl SliceIndex<str> for RangeInclusive<usize>

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

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

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

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

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

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

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

type Item = A;
fn spec_try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where
    Self: Sized,
    F: FnMut(B, A) -> R,
    R: Try<Output = B>,
fn spec_try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where
    Self: Sized,
    F: FnMut(B, A) -> R,
    R: Try<Output = B>,

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

impl<Idx: Clone> Clone for RangeInclusive<Idx>

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

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

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

impl<Idx: Hash> Hash for RangeInclusive<Idx>

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

impl<Idx: PartialEq> StructuralPartialEq for RangeInclusive<Idx>

impl<Idx: ~const Eq> Eq for RangeInclusive<Idx>

fn assert_fields_are_eq(&self)

impl<Idx: ~const PartialEq> PartialEq for RangeInclusive<Idx>

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

impl<T> From<RangeInclusive<T>> for RangeInclusive<T>

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

impl<T> IntoBounds<T> for RangeInclusive<T>

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

impl<T> RangeBounds<T> for RangeInclusive<&T>

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

impl<T> RangeBounds<T> for RangeInclusive<T>

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

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

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

impl<T: TrustedStep> RangeInclusiveIteratorImpl for RangeInclusive<T>

fn spec_try_fold<B, F, R>(&mut self, init: B, f: F) -> R
where
    Self: Sized,
    F: FnMut(B, T) -> R,
    R: Try<Output = B>,
fn spec_try_rfold<B, F, R>(&mut self, init: B, f: F) -> R
where
    Self: Sized,
    F: FnMut(B, T) -> R,
    R: Try<Output = B>,

Auto Trait Implementations

impl<Idx> Freeze for RangeInclusive<Idx> where Idx: Freeze + Freeze,

impl<Idx> RefUnwindSafe for RangeInclusive<Idx> where Idx: RefUnwindSafe + RefUnwindSafe,

impl<Idx> Send for RangeInclusive<Idx> where Idx: Send + Send,

impl<Idx> Sync for RangeInclusive<Idx> where Idx: Sync + Sync,

impl<Idx> Unpin for RangeInclusive<Idx> where Idx: Unpin + Unpin,

impl<Idx> UnsafeUnpin for RangeInclusive<Idx> where Idx: UnsafeUnpin + UnsafeUnpin,

impl<Idx> UnwindSafe for RangeInclusive<Idx> where Idx: UnwindSafe + UnwindSafe,

Blanket Implementations

impl<I> IntoIterator for RangeInclusive<Idx> where I: Iterator,

type Item = <I as Iterator>::Item;
type IntoIter = I;
fn into_iter(self) -> I

impl<T> Any for RangeInclusive<Idx> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for RangeInclusive<Idx> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for RangeInclusive<Idx> where T: ?Sized,

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

impl<T> CloneToUninit for RangeInclusive<Idx> where T: Clone,

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

impl<T> From<T> for RangeInclusive<Idx>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for RangeInclusive<Idx> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for RangeInclusive<Idx>

impl<T, U> Into<U> for RangeInclusive<Idx> where U: From<T>,

fn into(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<U> for RangeInclusive<Idx> where U: Into<T>,

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

impl<T, U> TryInto<U> for RangeInclusive<Idx> where U: TryFrom<T>,

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