Struct core::ops::RangeInclusive  
1.26.0 · source · pub struct RangeInclusive<Idx> { /* private fields */ }Expand description
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§
source§impl<Idx> RangeInclusive<Idx>
 
impl<Idx> RangeInclusive<Idx>
1.27.0 (const: 1.32.0) · sourcepub const fn start(&self) -> &Idx
 
pub 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);1.27.0 (const: 1.32.0) · sourcepub const fn end(&self) -> &Idx
 
pub 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);1.27.0 (const: unstable) · sourcepub fn into_inner(self) -> (Idx, Idx)
 
pub fn into_inner(self) -> (Idx, Idx)
source§impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx>
 
impl<Idx: PartialOrd<Idx>> RangeInclusive<Idx>
1.35.0 · sourcepub fn contains<U>(&self, item: &U) -> boolwhere
    Idx: PartialOrd<U>,
    U: ?Sized + PartialOrd<Idx>,
 
pub fn contains<U>(&self, item: &U) -> boolwhere Idx: PartialOrd<U>, U: ?Sized + 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));1.47.0 · sourcepub fn is_empty(&self) -> bool
 
pub fn is_empty(&self) -> bool
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§
source§impl<Idx: Clone> Clone for RangeInclusive<Idx>
 
impl<Idx: Clone> Clone for RangeInclusive<Idx>
source§impl<Idx: Debug> Debug for RangeInclusive<Idx>
 
impl<Idx: Debug> Debug for RangeInclusive<Idx>
source§impl<A: Step> DoubleEndedIterator for RangeInclusive<A>
 
impl<A: Step> DoubleEndedIterator for RangeInclusive<A>
source§fn next_back(&mut self) -> Option<A>
 
fn next_back(&mut self) -> Option<A>
source§fn nth_back(&mut self, n: usize) -> Option<A>
 
fn nth_back(&mut self, n: usize) -> Option<A>
nth element from the end of the iterator. Read moresource§fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Output = B>,
 
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> Rwhere Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,
Iterator::try_fold(): it takes
elements starting from the back of the iterator. Read moresource§fn rfold<AAA, FFF>(self, init: AAA, fold: FFF) -> AAAwhere
    FFF: FnMut(AAA, Self::Item) -> AAA,
 
fn rfold<AAA, FFF>(self, init: AAA, fold: FFF) -> AAAwhere FFF: FnMut(AAA, Self::Item) -> AAA,
source§fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
 
fn advance_back_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by #77404)n elements. Read moresource§impl ExactSizeIterator for RangeInclusive<i16>
 
impl ExactSizeIterator for RangeInclusive<i16>
source§impl ExactSizeIterator for RangeInclusive<i8>
 
impl ExactSizeIterator for RangeInclusive<i8>
source§impl ExactSizeIterator for RangeInclusive<u16>
 
impl ExactSizeIterator for RangeInclusive<u16>
source§impl ExactSizeIterator for RangeInclusive<u8>
 
impl ExactSizeIterator for RangeInclusive<u8>
source§impl<Idx: Hash> Hash for RangeInclusive<Idx>
 
impl<Idx: Hash> Hash for RangeInclusive<Idx>
source§impl<A: Step> Iterator for RangeInclusive<A>
 
impl<A: Step> Iterator for RangeInclusive<A>
source§fn size_hint(&self) -> (usize, Option<usize>)
 
fn size_hint(&self) -> (usize, Option<usize>)
source§fn count(self) -> usize
 
fn count(self) -> usize
source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Output = B>,
 
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,
source§fn fold<AAA, FFF>(self, init: AAA, fold: FFF) -> AAAwhere
    FFF: FnMut(AAA, Self::Item) -> AAA,
 
fn fold<AAA, FFF>(self, init: AAA, fold: FFF) -> AAAwhere FFF: FnMut(AAA, Self::Item) -> AAA,
source§fn is_sorted(self) -> bool
 
fn is_sorted(self) -> bool
is_sorted #53485)source§fn next_chunk<const N: usize>(
    &mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
    Self: Sized,
 
fn next_chunk<const N: usize>( &mut self ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where Self: Sized,
iter_next_chunk #98326)N values. Read moresource§fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
 
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by #77404)n elements. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self> ⓘwhere
    Self: Sized,
 
fn step_by(self, step: usize) -> StepBy<Self> ⓘwhere Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> ⓘwhere
    Self: Sized,
    U: IntoIterator<Item = Self::Item>,
 
fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> ⓘwhere Self: Sized, U: IntoIterator<Item = Self::Item>,
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> ⓘwhere
    Self: Sized,
    U: IntoIterator,
 
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> ⓘwhere Self: Sized, U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘwhere
    Self: Sized,
    G: FnMut() -> Self::Item,
 
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G> ⓘwhere Self: Sized, G: FnMut() -> Self::Item,
iter_intersperse #79524)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F> ⓘwhere
    Self: Sized,
    F: FnMut(Self::Item) -> B,
 
fn map<B, F>(self, f: F) -> Map<Self, F> ⓘwhere Self: Sized, F: FnMut(Self::Item) -> B,
1.21.0 · source§fn for_each<F>(self, f: F)where
    Self: Sized,
    F: FnMut(Self::Item),
 
fn for_each<F>(self, f: F)where Self: Sized, F: FnMut(Self::Item),
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘwhere
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
 
fn filter<P>(self, predicate: P) -> Filter<Self, P> ⓘwhere Self: Sized, P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> ⓘwhere
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>,
 
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> ⓘwhere Self: Sized, F: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn enumerate(self) -> Enumerate<Self> ⓘwhere
    Self: Sized,
 
fn enumerate(self) -> Enumerate<Self> ⓘwhere Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> ⓘwhere
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
 
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> ⓘwhere Self: Sized, P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> ⓘwhere
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
 
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> ⓘwhere Self: Sized, P: FnMut(&Self::Item) -> bool,
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> ⓘwhere
    Self: Sized,
    P: FnMut(Self::Item) -> Option<B>,
 
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> ⓘwhere Self: Sized, P: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self> ⓘwhere
    Self: Sized,
 
fn skip(self, n: usize) -> Skip<Self> ⓘwhere Self: Sized,
n elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self> ⓘwhere
    Self: Sized,
 
fn take(self, n: usize) -> Take<Self> ⓘwhere Self: Sized,
n elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> ⓘwhere
    Self: Sized,
    F: FnMut(&mut St, Self::Item) -> Option<B>,
 
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> ⓘwhere Self: Sized, F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> ⓘwhere
    Self: Sized,
    U: IntoIterator,
    F: FnMut(Self::Item) -> U,
 
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> ⓘwhere Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,
source§fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N> ⓘwhere
    Self: Sized,
    F: FnMut(&[Self::Item; N]) -> R,
 
fn map_windows<F, R, const N: usize>(self, f: F) -> MapWindows<Self, F, N> ⓘwhere Self: Sized, F: FnMut(&[Self::Item; N]) -> R,
iter_map_windows #87155)f for each contiguous window of size N over
self and returns an iterator over the outputs of f. Like slice::windows(),
the windows during mapping overlap as well. Read more1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘwhere
    Self: Sized,
    F: FnMut(&Self::Item),
 
fn inspect<F>(self, f: F) -> Inspect<Self, F> ⓘwhere Self: Sized, F: FnMut(&Self::Item),
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
    Self: Sized,
 
fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,
1.0.0 · source§fn collect<B: FromIterator<Self::Item>>(self) -> Bwhere
    Self: Sized,
 
fn collect<B: FromIterator<Self::Item>>(self) -> Bwhere Self: Sized,
source§fn collect_into<E: Extend<Self::Item>>(self, collection: &mut E) -> &mut Ewhere
    Self: Sized,
 
fn collect_into<E: Extend<Self::Item>>(self, collection: &mut E) -> &mut Ewhere Self: Sized,
iter_collect_into #94780)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)where
    Self: Sized,
    B: Default + Extend<Self::Item>,
    F: FnMut(&Self::Item) -> bool,
 
fn partition<B, F>(self, f: F) -> (B, B)where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,
source§fn partition_in_place<'a, T: 'a, P>(self, predicate: P) -> usizewhere
    Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
    P: FnMut(&T) -> bool,
 
fn partition_in_place<'a, T: 'a, P>(self, predicate: P) -> usizewhere Self: Sized + DoubleEndedIterator<Item = &'a mut T>, P: FnMut(&T) -> bool,
iter_partition_in_place #62543)true precede all those that return false.
Returns the number of true elements found. Read moresource§fn is_partitioned<P>(self, predicate: P) -> boolwhere
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
 
fn is_partitioned<P>(self, predicate: P) -> boolwhere Self: Sized, P: FnMut(Self::Item) -> bool,
iter_is_partitioned #62544)true precede all those that return false. Read more1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
    Self: Sized,
    F: FnMut(Self::Item) -> R,
    R: Try<Output = ()>,
 
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> Self::Item,
 
fn reduce<F>(self, f: F) -> Option<Self::Item>where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,
source§fn try_reduce<F, R>(
    &mut self,
    f: F
) -> <<R as Try>::Residual as Residual<Option<R::Output>>>::TryTypewhere
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> R,
    R: Try<Output = Self::Item>,
    R::Residual: Residual<Option<Self::Item>>,
 
fn try_reduce<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<R::Output>>>::TryTypewhere Self: Sized, F: FnMut(Self::Item, Self::Item) -> R, R: Try<Output = Self::Item>, R::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce #87053)1.0.0 · source§fn all<F>(&mut self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> bool,
 
fn all<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn any<F>(&mut self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> bool,
 
fn any<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool,
 
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>where
    Self: Sized,
    F: FnMut(Self::Item) -> Option<B>,
 
fn find_map<B, F>(&mut self, f: F) -> Option<B>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,
source§fn try_find<F, R>(
    &mut self,
    f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
    Self: Sized,
    F: FnMut(&Self::Item) -> R,
    R: Try<Output = bool>,
    R::Residual: Residual<Option<Self::Item>>,
 
fn try_find<F, R>( &mut self, f: F ) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere Self: Sized, F: FnMut(&Self::Item) -> R, R: Try<Output = bool>, R::Residual: Residual<Option<Self::Item>>,
try_find #63178)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>where
    Self: Sized,
    P: FnMut(Self::Item) -> bool,
 
fn position<P>(&mut self, predicate: P) -> Option<usize>where Self: Sized, P: FnMut(Self::Item) -> bool,
1.6.0 · source§fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(&Self::Item) -> B,
 
fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
 
fn max_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · source§fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(&Self::Item) -> B,
 
fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>where
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Ordering,
 
fn min_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0 · source§fn rev(self) -> Rev<Self> ⓘwhere
    Self: Sized + DoubleEndedIterator,
 
fn rev(self) -> Rev<Self> ⓘwhere Self: Sized + DoubleEndedIterator,
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
    FromA: Default + Extend<A>,
    FromB: Default + Extend<B>,
    Self: Sized + Iterator<Item = (A, B)>,
 
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self> ⓘwhere
    Self: Sized + Iterator<Item = &'a T>,
    T: Copy + 'a,
 
fn copied<'a, T>(self) -> Copied<Self> ⓘwhere Self: Sized + Iterator<Item = &'a T>, T: Copy + 'a,
1.0.0 · source§fn cloned<'a, T>(self) -> Cloned<Self> ⓘwhere
    Self: Sized + Iterator<Item = &'a T>,
    T: Clone + 'a,
 
fn cloned<'a, T>(self) -> Cloned<Self> ⓘwhere Self: Sized + Iterator<Item = &'a T>, T: Clone + 'a,
1.0.0 · source§fn cycle(self) -> Cycle<Self> ⓘwhere
    Self: Sized + Clone,
 
fn cycle(self) -> Cycle<Self> ⓘwhere Self: Sized + Clone,
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N> ⓘwhere
    Self: Sized,
 
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N> ⓘwhere Self: Sized,
iter_array_chunks #100450)N elements of the iterator at a time. Read more1.11.0 · source§fn sum<S>(self) -> Swhere
    Self: Sized,
    S: Sum<Self::Item>,
 
fn sum<S>(self) -> Swhere Self: Sized, S: Sum<Self::Item>,
1.11.0 · source§fn product<P>(self) -> Pwhere
    Self: Sized,
    P: Product<Self::Item>,
 
fn product<P>(self) -> Pwhere Self: Sized, P: Product<Self::Item>,
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> Ordering,
 
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, I::Item) -> Ordering,
iter_order_by #64295)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized,
 
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized,
PartialOrd elements of
this Iterator with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> Option<Ordering>,
 
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where Self: Sized, I: IntoIterator, F: FnMut(Self::Item, I::Item) -> Option<Ordering>,
iter_order_by #64295)Iterator with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn eq<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialEq<I::Item>,
    Self: Sized,
 
fn eq<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<I::Item>, Self: Sized,
source§fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
    Self: Sized,
    I: IntoIterator,
    F: FnMut(Self::Item, I::Item) -> bool,
 
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, I::Item) -> bool,
iter_order_by #64295)1.5.0 · source§fn ne<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialEq<I::Item>,
    Self: Sized,
 
fn ne<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<I::Item>, Self: Sized,
1.5.0 · source§fn lt<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized,
 
fn lt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized,
Iterator are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized,
 
fn le<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized,
Iterator are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized,
 
fn gt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized,
Iterator are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> boolwhere
    I: IntoIterator,
    Self::Item: PartialOrd<I::Item>,
    Self: Sized,
 
fn ge<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<I::Item>, Self: Sized,
Iterator are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> boolwhere
    Self: Sized,
    F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
 
fn is_sorted_by<F>(self, compare: F) -> boolwhere Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted #53485)source§fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
    Self: Sized,
    F: FnMut(Self::Item) -> K,
    K: PartialOrd,
 
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd,
is_sorted #53485)source§impl<Idx: PartialEq> PartialEq for RangeInclusive<Idx>
 
impl<Idx: PartialEq> PartialEq for RangeInclusive<Idx>
source§fn eq(&self, other: &RangeInclusive<Idx>) -> bool
 
fn eq(&self, other: &RangeInclusive<Idx>) -> bool
self and other values to be equal, and is used
by ==.1.28.0 · source§impl<T> RangeBounds<T> for RangeInclusive<&T>
 
impl<T> RangeBounds<T> for RangeInclusive<&T>
1.28.0 · source§impl<T> RangeBounds<T> for RangeInclusive<T>
 
impl<T> RangeBounds<T> for RangeInclusive<T>
const: unstable · source§impl<T> SliceIndex<[T]> for RangeInclusive<usize>
 
impl<T> SliceIndex<[T]> for RangeInclusive<usize>
const: unstable · source§fn get(self, slice: &[T]) -> Option<&[T]>
 
fn get(self, slice: &[T]) -> Option<&[T]>
slice_index_methods)const: unstable · source§fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>
 
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>
slice_index_methods)const: unstable · source§unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]
 
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]
slice_index_methods)slice pointer
is undefined behavior even if the resulting reference is not used.const: unstable · source§unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]
 
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]
slice_index_methods)slice pointer
is undefined behavior even if the resulting reference is not used.const: unstable · source§impl SliceIndex<str> for RangeInclusive<usize>
 
impl SliceIndex<str> for RangeInclusive<usize>
Implements substring slicing with syntax &self[begin ..= end] or &mut self[begin ..= end].
Returns a slice of the given string from the byte range
[begin, end]. Equivalent to &self [begin .. end + 1] or &mut self[begin .. end + 1], except if end has the maximum value for
usize.
This operation is O(1).
Panics
Panics if begin does not point to the starting byte offset of
a character (as defined by is_char_boundary), if end does not point
to the ending byte offset of a character (end + 1 is either a starting
byte offset or equal to len), if begin > end, or if end >= len.
const: unstable · source§fn get(self, slice: &str) -> Option<&Self::Output>
 
fn get(self, slice: &str) -> Option<&Self::Output>
slice_index_methods)const: unstable · source§fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
 
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
slice_index_methods)const: unstable · source§unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
 
unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
slice_index_methods)slice pointer
is undefined behavior even if the resulting reference is not used.const: unstable · source§unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
 
unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
slice_index_methods)slice pointer
is undefined behavior even if the resulting reference is not used.