Struct RangeInclusive

pub struct RangeInclusive<Idx> {
    pub start: Idx,
    pub end: Idx,
}

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

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.

Examples

The start..=end syntax is a RangeInclusive:

#![feature(new_range_api)]
use core::range::RangeInclusive;

assert_eq!(RangeInclusive::from(3..=5), RangeInclusive { start: 3, end: 5 });
assert_eq!(3 + 4 + 5, RangeInclusive::from(3..=5).into_iter().sum());

Fields

start: Idx

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

The lower bound of the range (inclusive).

end: Idx

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

The upper bound of the range (inclusive).

Implementations

impl<Idx> RangeInclusive<Idx>

where Idx: PartialOrd,

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

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

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

Returns true if item is contained in the range.

Examples

#![feature(new_range_api)]
use core::range::RangeInclusive;

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

assert!( RangeInclusive::from(3..=3).contains(&3));
assert!(!RangeInclusive::from(3..=2).contains(&3));

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

pub fn is_empty(&self) -> bool

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

Returns true if the range contains no items.

Examples

#![feature(new_range_api)]
use core::range::RangeInclusive;

assert!(!RangeInclusive::from(3..=5).is_empty());
assert!(!RangeInclusive::from(3..=3).is_empty());
assert!( RangeInclusive::from(3..=2).is_empty());

The range is empty if either side is incomparable:

#![feature(new_range_api)]
use core::range::RangeInclusive;

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

impl<Idx> RangeInclusive<Idx>

where Idx: Step,

pub fn iter(&self) -> IterRangeInclusive<Idx>

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

Creates an iterator over the elements within this range.

Shorthand for .clone().into_iter()

Examples

#![feature(new_range_api)]
use core::range::RangeInclusive;

let mut i = RangeInclusive::from(3..=8).iter().map(|n| n*n);
assert_eq!(i.next(), Some(9));
assert_eq!(i.next(), Some(16));
assert_eq!(i.next(), Some(25));

Trait Implementations

impl<Idx> Clone for RangeInclusive<Idx>

where Idx: Clone,

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Idx> Debug for RangeInclusive<Idx>

where Idx: Debug,

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

Formats the value using the given formatter.

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

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

Converts to this type from the input type.

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

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

Converts to this type from the input type.

impl GetDisjointMutIndex for RangeInclusive<usize>

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

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

Returns true if self is in bounds for len slice elements.

fn is_overlapping(&self, other: &RangeInclusive<usize>) -> bool

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

Returns true if self overlaps with other.

impl<Idx> Hash for RangeInclusive<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> IntoBounds<T> for RangeInclusive<T>

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

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

Convert this range into the start and end bounds. Returns (start_bound, end_bound).

fn intersect<R>(self, other: R) -> (Bound<T>, Bound<T>)

where Self: Sized, T: Ord, R: IntoBounds<T>,

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

Compute the intersection of self and other.

impl<A> IntoIterator for RangeInclusive<A>

where A: Step,

type Item = A

The type of the elements being iterated over.

type IntoIter = IterRangeInclusive<A>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <RangeInclusive<A> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<Idx> PartialEq for RangeInclusive<Idx>

where Idx: PartialEq,

fn eq(&self, other: &RangeInclusive<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 RangeInclusive<&T>

If you need to use this implementation where T is unsized, consider using the RangeBounds impl for a 2-tuple of Bound<&T>, i.e. replace start..=end with (Bound::Included(start), Bound::Included(end)).

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.

fn is_empty(&self) -> bool

where T: PartialOrd,

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

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

impl<T> RangeBounds<T> for RangeInclusive<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.

fn is_empty(&self) -> bool

where T: PartialOrd,

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

Returns true if the range contains no items. One-sided ranges (RangeFrom, etc) always return false.

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

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<ByteStr> for RangeInclusive<usize>

type Output = ByteStr

The output type returned by methods.

fn get( self, slice: &ByteStr, ) -> Option<&<RangeInclusive<usize> as SliceIndex<ByteStr>>::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 ByteStr, ) -> Option<&mut <RangeInclusive<usize> as SliceIndex<ByteStr>>::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 ByteStr, ) -> *const <RangeInclusive<usize> as SliceIndex<ByteStr>>::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 ByteStr, ) -> *mut <RangeInclusive<usize> as SliceIndex<ByteStr>>::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: &ByteStr, ) -> &<RangeInclusive<usize> as SliceIndex<ByteStr>>::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 ByteStr, ) -> &mut <RangeInclusive<usize> as SliceIndex<ByteStr>>::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 SliceIndex<str> for RangeInclusive<usize>

type Output = str

The output type returned by methods.

fn get( self, slice: &str, ) -> Option<&<RangeInclusive<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 <RangeInclusive<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 <RangeInclusive<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 <RangeInclusive<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, ) -> &<RangeInclusive<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 <RangeInclusive<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 RangeInclusive<Idx>

where Idx: Copy,

impl<Idx> Eq for RangeInclusive<Idx>

where Idx: Eq,

impl<Idx> StructuralPartialEq for RangeInclusive<Idx>