Struct RangeInclusive 

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

A range bounded inclusively below and above.

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

Examples

use core::range::RangeInclusive;

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

Edition notes

It is planned that the syntax start..=last will construct this type in a future edition, but it does not do so today.

Fields

start: Idx

The lower bound of the range (inclusive).

last: Idx

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,

Returns true if item is contained in the range.

Examples

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

where Idx: PartialOrd,

Returns true if the range contains no items.

Examples

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:

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) -> RangeInclusiveIter<Idx>

Creates an iterator over the elements within this range.

Shorthand for .clone().into_iter()

Examples

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> Copy for RangeInclusive<Idx>

where Idx: Copy,

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 Distribution<i8> for RangeInclusive<i8>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> i8

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<i16> for RangeInclusive<i16>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> i16

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<i32> for RangeInclusive<i32>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> i32

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<i64> for RangeInclusive<i64>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> i64

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<i128> for RangeInclusive<i128>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> i128

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<isize> for RangeInclusive<isize>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> isize

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<u8> for RangeInclusive<u8>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> u8

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<u16> for RangeInclusive<u16>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> u16

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<u32> for RangeInclusive<u32>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> u32

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<u64> for RangeInclusive<u64>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> u64

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<u128> for RangeInclusive<u128>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> u128

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl Distribution<usize> for RangeInclusive<usize>

fn sample(&self, source: &mut (impl Rng + ?Sized)) -> usize

🔬This is a nightly-only experimental API. (random #130703)

Chooses a random number within the range.

Every possible result value is equally likely. In other words, this operation uses unbiased uniform sampling.

Panics

Panics if the range is empty.

Side-channels

This implementation does not claim to be resistant against side- channel attacks. In particular, the execution time of this operation may leak information about the returned value, and not just the values of the range bounds. While this implementation tries to avoid operations with particularly data-dependent timing (such as divisions), Rust as a language has no facilities for ensuring data-independent timing, voiding all promises about side-channel- freedom.

Examples

A D20 dice roll:

#![feature(random)]

use std::random::{Distribution, SystemRng};
use std::range::RangeInclusive;

let roll = RangeInclusive::from(1..=20).sample(&mut SystemRng);
assert!(1 <= roll && roll <= 20);
if roll == 20 {
    println!("Wow! You achieve writing a sound linked list.");
} else {
    println!("Miri attacks!");
}

impl<Idx> Eq for RangeInclusive<Idx>

where Idx: Eq,

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 from a legacy range to a non-legacy range, potentially panicking.

Panics

If the legacy range iterator has been exhausted, this function will either panic or return an empty range.

Examples

use core::range::legacy;
use core::range::RangeInclusive;

let single: legacy::RangeInclusive<i32> = 0..=1;
let single = RangeInclusive::from(single);
assert_eq!((single.start, single.last), (0, 1));

let empty: legacy::RangeInclusive<i32> = 0..=0;
let empty = RangeInclusive::from(empty);
assert_eq!((empty.start, empty.last), (0, 0));

use core::range::legacy;
use core::range::RangeInclusive;
use std::panic::catch_unwind;

let mut exhausted: legacy::RangeInclusive<i32> = 0..=0;
exhausted.next();
let result = catch_unwind(|| RangeInclusive::from(exhausted));
// The `from` call either panicked or returned an empty range.
assert!(result.is_err() || result.is_ok_and(|range| range.is_empty()));

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 #136903)

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 #136903)

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 = RangeInclusiveIter<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

Equality operator ==.

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

Inequality operator !=.

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 #137300)

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

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 #137300)

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

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<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<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> StructuralPartialEq for RangeInclusive<Idx>

where Idx: PartialEq,