W3cubDocs

/Rust

Struct std::ops::RangeInclusive

#[lang = "RangeInclusive"]pub struct RangeInclusive<Idx> { /* fields omitted */ }

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

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  ]);  // RangeInclusive

Implementations

`impl<Idx> RangeInclusive<Idx>`[src]

#[lang = "range_inclusive_new"]pub const fn new(start: Idx, end: Idx) -> RangeInclusive<Idx>ⓘNotable traits for RangeInclusive<A>
impl<A> Iterator for RangeInclusive<A> where
    A: Step, 
    type Item = A;

[src]1.27.0

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

Examples

use std::ops::RangeInclusive;

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

pub const fn start(&self) -> &IdxⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]1.27.0

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);

pub const fn end(&self) -> &IdxⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]1.27.0

Returns the upper bound of the range (inclusive).

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

Examples

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

`pub fn into_inner(self) -> (Idx, Idx)`[src]1.27.0

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> RangeInclusive<Idx> where Idx: PartialOrd<Idx>,` [src]

`pub fn contains(&self, item: &U) -> bool where Idx: PartialOrd, U: PartialOrd<Idx> + ?Sized,` [src]1.35.0

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));

`pub fn is_empty(&self) -> bool`[src]1.47.0

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<Idx> Clone for RangeInclusive<Idx> where Idx: Clone,` [src]

fn clone(&self) -> RangeInclusive<Idx>ⓘNotable traits for RangeInclusive<A>
impl<A> Iterator for RangeInclusive<A> where
    A: Step, 
    type Item = A;

[src]

`fn clone_from(&mut self, source: &Self)`[src]1.0.0

`impl<Idx> Debug for RangeInclusive<Idx> where Idx: Debug,` [src]

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

`impl<A> DoubleEndedIterator for RangeInclusive<A> where A: Step,` [src]

`fn next_back(&mut self) -> Option<A>`[src]

`fn nth_back(&mut self, n: usize) -> Option<A>`[src]

`fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Ok = B>, RangeInclusive<A>: Sized,` [src]

`fn rfold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> B, RangeInclusive<A>: Sized,` [src]

`fn rfind(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,` [src]1.27.0

`impl<Idx> Eq for RangeInclusive<Idx> where Idx: Eq,` [src]

`impl ExactSizeIterator for RangeInclusive<u16>`[src]

`fn len(&self) -> usize`[src]1.0.0

`fn is_empty(&self) -> bool`[src]

`impl ExactSizeIterator for RangeInclusive<u8>`[src]

`fn len(&self) -> usize`[src]1.0.0

`fn is_empty(&self) -> bool`[src]

`impl ExactSizeIterator for RangeInclusive<i8>`[src]

`fn len(&self) -> usize`[src]1.0.0

`fn is_empty(&self) -> bool`[src]

`impl ExactSizeIterator for RangeInclusive<i16>`[src]

`fn len(&self) -> usize`[src]1.0.0

`fn is_empty(&self) -> bool`[src]

`impl<A> FusedIterator for RangeInclusive<A> where A: Step,` [src]

`impl<Idx> Hash for RangeInclusive<Idx> where Idx: Hash,` [src]

`fn hash<H>(&self, state: &mut H) where __H: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl Index<RangeInclusive<usize>> for String`[src]

`type Output = str`

The returned type after indexing.

`fn index(&self, index: RangeInclusive<usize>) -> &str`[src]

`impl IndexMut<RangeInclusive<usize>> for String`[src]

`fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str`[src]

`impl<A> Iterator for RangeInclusive<A> where A: Step,` [src]

`type Item = A`

The type of the elements being iterated over.

`fn next(&mut self) -> Option<A>`[src]

`fn size_hint(&self) -> (usize, Option<usize>)`[src]

`fn nth(&mut self, n: usize) -> Option<A>`[src]

`fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Ok = B>, RangeInclusive<A>: Sized,` [src]

`fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> B, RangeInclusive<A>: Sized,` [src]

`fn last(self) -> Option<A>`[src]

`fn min(self) -> Option<A>`[src]

`fn max(self) -> Option<A>`[src]

`fn count(self) -> usize`[src]1.0.0

fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I>
impl<I> Iterator for StepBy<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.28.0

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B>
impl<A, B> Iterator for Chain<A, B> where
    A: Iterator,
    B: Iterator<Item = <A as Iterator>::Item>, 
    type Item = <A as Iterator>::Item;
 where
    U: IntoIterator<Item = Self::Item>,

[src]1.0.0

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B>
impl<A, B> Iterator for Zip<A, B> where
    A: Iterator,
    B: Iterator, 
    type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
 where
    U: IntoIterator,

[src]1.0.0

fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F>
impl<B, I, F> Iterator for Map<I, F> where
    F: FnMut(<I as Iterator>::Item) -> B,
    I: Iterator, 
    type Item = B;
 where
    F: FnMut(Self::Item) -> B,

[src]1.0.0

`fn for_each<F>(self, f: F) where F: FnMut(Self::Item),` [src]1.21.0

fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P>
impl<I, P> Iterator for Filter<I, P> where
    I: Iterator,
    P: FnMut(&<I as Iterator>::Item) -> bool, 
    type Item = <I as Iterator>::Item;
 where
    P: FnMut(&Self::Item) -> bool,

[src]1.0.0

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F>
impl<B, I, F> Iterator for FilterMap<I, F> where
    F: FnMut(<I as Iterator>::Item) -> Option<B>,
    I: Iterator, 
    type Item = B;
 where
    F: FnMut(Self::Item) -> Option<B>,

[src]1.0.0

fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I>
impl<I> Iterator for Enumerate<I> where
    I: Iterator, 
    type Item = (usize, <I as Iterator>::Item);

[src]1.0.0

fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I>
impl<I> Iterator for Peekable<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.0.0

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P>
impl<I, P> Iterator for SkipWhile<I, P> where
    I: Iterator,
    P: FnMut(&<I as Iterator>::Item) -> bool, 
    type Item = <I as Iterator>::Item;
 where
    P: FnMut(&Self::Item) -> bool,

[src]1.0.0

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P>
impl<I, P> Iterator for TakeWhile<I, P> where
    I: Iterator,
    P: FnMut(&<I as Iterator>::Item) -> bool, 
    type Item = <I as Iterator>::Item;
 where
    P: FnMut(&Self::Item) -> bool,

[src]1.0.0

fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P>
impl<B, I, P> Iterator for MapWhile<I, P> where
    I: Iterator,
    P: FnMut(<I as Iterator>::Item) -> Option<B>, 
    type Item = B;
 where
    P: FnMut(Self::Item) -> Option<B>,

[src]

fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I>
impl<I> Iterator for Skip<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.0.0

fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I>
impl<I> Iterator for Take<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.0.0

fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>ⓘNotable traits for Scan<I, St, F>
impl<B, I, St, F> Iterator for Scan<I, St, F> where
    F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>,
    I: Iterator, 
    type Item = B;
 where
    F: FnMut(&mut St, Self::Item) -> Option<B>,

[src]1.0.0

fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘNotable traits for FlatMap<I, U, F>
impl<I, U, F> Iterator for FlatMap<I, U, F> where
    F: FnMut(<I as Iterator>::Item) -> U,
    I: Iterator,
    U: IntoIterator, 
    type Item = <U as IntoIterator>::Item;
 where
    F: FnMut(Self::Item) -> U,
    U: IntoIterator,

[src]1.0.0

fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<I>
impl<I, U> Iterator for Flatten<I> where
    I: Iterator,
    U: Iterator,
    <I as Iterator>::Item: IntoIterator,
    <<I as Iterator>::Item as IntoIterator>::IntoIter == U,
    <<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item, 
    type Item = <U as Iterator>::Item;
 where
    Self::Item: IntoIterator,

[src]1.29.0

fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I>
impl<I> Iterator for Fuse<I> where
    I: Iterator, 
    type Item = <I as Iterator>::Item;

[src]1.0.0

fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>
impl<I, F> Iterator for Inspect<I, F> where
    F: FnMut(&<I as Iterator>::Item),
    I: Iterator, 
    type Item = <I as Iterator>::Item;
 where
    F: FnMut(&Self::Item),

[src]1.0.0

fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]1.0.0

#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect(self) -> B where B: FromIterator<Self::Item>, [src]1.0.0

`fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where P: FnMut(&T) -> bool, Self: DoubleEndedIterator<Item = &'a mut T>, T: 'a,` [src]

`fn is_partitioned(self, predicate: P) -> bool where P: FnMut(Self::Item) -> bool,` [src]

`fn try_for_each<F, R>(&mut self, f: F) -> R where F: FnMut(Self::Item) -> R, R: Try<Ok = ()>,` [src]1.27.0

`fn fold_first<F>(self, f: F) -> Option<Self::Item> where F: FnMut(Self::Item, Self::Item) -> Self::Item,` [src]

`fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn find(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn find_map<B, F>(&mut self, f: F) -> Option where F: FnMut(Self::Item) -> Option,` [src]1.30.0

`fn try_find<F, R>( &mut self, f: F ) -> Result<Option<Self::Item>, <R as Try>::Error> where F: FnMut(&Self::Item) -> R, R: Try<Ok = bool>,` [src]

`fn position(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn rposition(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator,` [src]1.0.0

`fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]1.6.0

`fn max_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]1.15.0

`fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]1.6.0

`fn min_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]1.15.0

fn rev(self) -> Rev<Self>ⓘNotable traits for Rev<I>
impl<I> Iterator for Rev<I> where
    I: DoubleEndedIterator, 
    type Item = <I as Iterator>::Item;
 where
    Self: DoubleEndedIterator,

[src]1.0.0

`fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where FromA: Default + Extend<A>, FromB: Default + Extend, Self: Iterator<Item = (A, B)>,` [src]1.0.0

fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>
impl<'a, I, T> Iterator for Copied<I> where
    I: Iterator<Item = &'a T>,
    T: 'a + Copy, 
    type Item = T;
 where
    Self: Iterator<Item = &'a T>,
    T: 'a + Copy,

[src]1.36.0

fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>
impl<'a, I, T> Iterator for Cloned<I> where
    I: Iterator<Item = &'a T>,
    T: 'a + Clone, 
    type Item = T;
 where
    Self: Iterator<Item = &'a T>,
    T: 'a + Clone,

[src]1.0.0

fn cycle(self) -> Cycle<Self>ⓘNotable traits for Cycle<I>
impl<I> Iterator for Cycle<I> where
    I: Clone + Iterator, 
    type Item = <I as Iterator>::Item;
 where
    Self: Clone,

[src]1.0.0

`fn sum<S>(self) -> S where S: Sum<Self::Item>,` [src]1.11.0

`fn product(self) -> P where P: Product<Self::Item>,` [src]1.11.0

`fn cmp(self, other: I) -> Ordering where I: IntoIterator<Item = Self::Item>, Self::Item: Ord,` [src]1.5.0

`fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where F: FnMut(Self::Item, ::Item) -> Ordering, I: IntoIterator,` [src]

`fn partial_cmp(self, other: I) -> Option<Ordering> where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where F: FnMut(Self::Item, ::Item) -> Option<Ordering>, I: IntoIterator,` [src]

`fn eq(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<::Item>,` [src]1.5.0

`fn eq_by<I, F>(self, other: I, eq: F) -> bool where F: FnMut(Self::Item, ::Item) -> bool, I: IntoIterator,` [src]

`fn ne(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialEq<::Item>,` [src]1.5.0

`fn lt(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn le(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn gt(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn ge(self, other: I) -> bool where I: IntoIterator, Self::Item: PartialOrd<::Item>,` [src]1.5.0

`fn is_sorted(self) -> bool where Self::Item: PartialOrd<Self::Item>,` [src]

`fn is_sorted_by<F>(self, compare: F) -> bool where F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,` [src]

`fn is_sorted_by_key<F, K>(self, f: F) -> bool where F: FnMut(Self::Item) -> K, K: PartialOrd<K>,` [src]

`impl<Idx> PartialEq<RangeInclusive<Idx>> for RangeInclusive<Idx> where Idx: PartialEq<Idx>,` [src]

`fn eq(&self, other: &RangeInclusive<Idx>) -> bool`[src]

`fn ne(&self, other: &RangeInclusive<Idx>) -> bool`[src]

`impl<'_, T> RangeBounds<T> for RangeInclusive<&'_ T>`[src]1.28.0

`fn start_bound(&self) -> Bound<&T>`[src]

`fn end_bound(&self) -> Bound<&T>`[src]

`fn contains(&self, item: &U) -> bool where T: PartialOrd, U: PartialOrd<T> + ?Sized,` [src]1.35.0

`impl<T> RangeBounds<T> for RangeInclusive<T>`[src]1.28.0

`fn start_bound(&self) -> Bound<&T>`[src]

`fn end_bound(&self) -> Bound<&T>`[src]

`fn contains(&self, item: &U) -> bool where T: PartialOrd, U: PartialOrd<T> + ?Sized,` [src]1.35.0

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

`type Output = [T]`

The output type returned by methods.

`fn get(self, slice: &[T]) -> Option<&[T]>`[src]

`fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>`[src]

`unsafe fn get_unchecked(self, slice: const [T]) -> const [T]`[src]

`unsafe fn get_unchecked_mut(self, slice: mut [T]) -> mut [T]`[src]

fn index(self, slice: &[T]) -> &[T]ⓘNotable traits for &'_ [u8]
impl<'_> Read for &'_ [u8]
impl<'_> Write for &'_ mut [u8]

[src]

fn index_mut(self, slice: &mut [T]) -> &mut [T]ⓘNotable traits for &'_ [u8]
impl<'_> Read for &'_ [u8]
impl<'_> Write for &'_ mut [u8]

[src]

`impl SliceIndex<str> for RangeInclusive<usize>`[src]

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.

`type Output = str`

The output type returned by methods.

`fn get( self, slice: &str ) -> Option<&<RangeInclusive<usize> as SliceIndex<str>>::Output>`[src]

`fn get_mut( self, slice: &mut str ) -> Option<&mut <RangeInclusive<usize> as SliceIndex<str>>::Output>`[src]

`unsafe fn get_unchecked( self, slice: const str ) -> const <RangeInclusive<usize> as SliceIndex<str>>::Output`[src]

`unsafe fn get_unchecked_mut( self, slice: mut str ) -> mut <RangeInclusive<usize> as SliceIndex<str>>::Output`[src]

fn index(
    self, 
    slice: &str
) -> &<RangeInclusive<usize> as SliceIndex<str>>::OutputⓘNotable traits for RangeInclusive<A>
impl<A> Iterator for RangeInclusive<A> where
    A: Step, 
    type Item = A;

[src]

fn index_mut(
    self, 
    slice: &mut str
) -> &mut <RangeInclusive<usize> as SliceIndex<str>>::OutputⓘNotable traits for RangeInclusive<A>
impl<A> Iterator for RangeInclusive<A> where
    A: Step, 
    type Item = A;

[src]

`impl<Idx> StructuralEq for RangeInclusive<Idx>`[src]

`impl<Idx> StructuralPartialEq for RangeInclusive<Idx>`[src]

`impl<A> TrustedLen for RangeInclusive<A> where A: Step,` [src]

Auto Trait Implementations

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

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

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

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

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

Blanket Implementations

`impl<T> Any for T where T: 'static + ?Sized,` [src]

`fn type_id(&self) -> TypeId`[src]

`impl<T> Borrow<T> for T where T: ?Sized,` [src]

fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> BorrowMut<T> for T where T: ?Sized,` [src]

fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized, 
    type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
    I: Iterator + ?Sized, 
    type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W

[src]

`impl<T> From<T> for T`[src]

`fn from(t: T) -> T`[src]

`impl<T, U> Into for T where U: From<T>,` [src]

`fn into(self) -> U`[src]

`impl IntoIterator for I where I: Iterator,` [src]

`type Item = ::Item`

The type of the elements being iterated over.

`type IntoIter = I`

Which kind of iterator are we turning this into?

`fn into_iter(self) -> I`[src]

`impl<T> ToOwned for T where T: Clone,` [src]

`type Owned = T`

The resulting type after obtaining ownership.

`fn to_owned(&self) -> T`[src]

`fn clone_into(&self, target: &mut T)`[src]

`impl<T, U> TryFrom for T where U: Into<T>,` [src]

`type Error = Infallible`

The type returned in the event of a conversion error.

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

`impl<T, U> TryInto for T where U: TryFrom<T>,` [src]

`type Error = >::Error`

The type returned in the event of a conversion error.

`fn try_into(self) -> Result<U, >::Error>`[src]

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/ops/struct.RangeInclusive.html

Struct std::ops::RangeInclusive

Examples

Implementations

impl<Idx> RangeInclusive<Idx>[src]

#[lang = "range_inclusive_new"]pub const fn new(start: Idx, end: Idx) -> RangeInclusive<Idx>ⓘNotable traits for RangeInclusive<A> impl<A> Iterator for RangeInclusive<A> where A: Step, type Item = A; [src]1.27.0

Notable traits for RangeInclusive<A>

Examples

Notable traits for &'_ mut F

Examples

Notable traits for &'_ mut F

Examples

pub fn into_inner(self) -> (Idx, Idx)[src]1.27.0

Examples

impl<Idx> RangeInclusive<Idx> where Idx: PartialOrd<Idx>, [src]

pub fn contains<U>(&self, item: &U) -> bool where Idx: PartialOrd<U>, U: PartialOrd<Idx> + ?Sized, [src]1.35.0

Examples

pub fn is_empty(&self) -> bool[src]1.47.0

Examples

Trait Implementations

impl<Idx> Clone for RangeInclusive<Idx> where Idx: Clone, [src]

fn clone(&self) -> RangeInclusive<Idx>ⓘNotable traits for RangeInclusive<A> impl<A> Iterator for RangeInclusive<A> where A: Step, type Item = A; [src]

Notable traits for RangeInclusive<A>

fn clone_from(&mut self, source: &Self)[src]1.0.0

impl<Idx> Debug for RangeInclusive<Idx> where Idx: Debug, [src]

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

impl<A> DoubleEndedIterator for RangeInclusive<A> where A: Step, [src]

fn next_back(&mut self) -> Option<A>[src]

fn nth_back(&mut self, n: usize) -> Option<A>[src]

fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Ok = B>, RangeInclusive<A>: Sized, [src]

fn rfold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> B, RangeInclusive<A>: Sized, [src]

fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool, [src]1.27.0

impl<Idx> Eq for RangeInclusive<Idx> where Idx: Eq, [src]

impl ExactSizeIterator for RangeInclusive<u16>[src]

fn len(&self) -> usize[src]1.0.0

fn is_empty(&self) -> bool[src]

impl ExactSizeIterator for RangeInclusive<u8>[src]

fn len(&self) -> usize[src]1.0.0

fn is_empty(&self) -> bool[src]

impl ExactSizeIterator for RangeInclusive<i8>[src]

fn len(&self) -> usize[src]1.0.0

fn is_empty(&self) -> bool[src]

impl ExactSizeIterator for RangeInclusive<i16>[src]

fn len(&self) -> usize[src]1.0.0

fn is_empty(&self) -> bool[src]

impl<A> FusedIterator for RangeInclusive<A> where A: Step, [src]

impl<Idx> Hash for RangeInclusive<Idx> where Idx: Hash, [src]

fn hash<__H>(&self, state: &mut __H) where __H: Hasher, [src]

fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher, [src]1.3.0

impl Index<RangeInclusive<usize>> for String[src]

type Output = str

fn index(&self, index: RangeInclusive<usize>) -> &str[src]

impl IndexMut<RangeInclusive<usize>> for String[src]

fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str[src]

impl<A> Iterator for RangeInclusive<A> where A: Step, [src]

type Item = A

fn next(&mut self) -> Option<A>[src]

fn size_hint(&self) -> (usize, Option<usize>)[src]

fn nth(&mut self, n: usize) -> Option<A>[src]

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Ok = B>, RangeInclusive<A>: Sized, [src]

fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> B, RangeInclusive<A>: Sized, [src]

fn last(self) -> Option<A>[src]

fn min(self) -> Option<A>[src]

fn max(self) -> Option<A>[src]

fn count(self) -> usize[src]1.0.0

fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I> impl<I> Iterator for StepBy<I> where I: Iterator, type Item = <I as Iterator>::Item; [src]1.28.0

Notable traits for StepBy<I>

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B> impl<A, B> Iterator for Chain<A, B> where A: Iterator, B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item; where U: IntoIterator<Item = Self::Item>, [src]1.0.0

Notable traits for Chain<A, B>

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B> impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item); where U: IntoIterator, [src]1.0.0

Notable traits for Zip<A, B>

fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F> impl<B, I, F> Iterator for Map<I, F> where F: FnMut(<I as Iterator>::Item) -> B, I: Iterator, type Item = B; where F: FnMut(Self::Item) -> B, [src]1.0.0

Notable traits for Map<I, F>

fn for_each<F>(self, f: F) where F: FnMut(Self::Item), [src]1.21.0

fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P> impl<I, P> Iterator for Filter<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool, [src]1.0.0

Notable traits for Filter<I, P>

fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F> impl<B, I, F> Iterator for FilterMap<I, F> where F: FnMut(<I as Iterator>::Item) -> Option<B>, I: Iterator, type Item = B; where F: FnMut(Self::Item) -> Option<B>, [src]1.0.0

Notable traits for FilterMap<I, F>

fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I> impl<I> Iterator for Enumerate<I> where I: Iterator, type Item = (usize, <I as Iterator>::Item); [src]1.0.0

Notable traits for Enumerate<I>

fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I> impl<I> Iterator for Peekable<I> where I: Iterator, type Item = <I as Iterator>::Item; [src]1.0.0

`impl<Idx> RangeInclusive<Idx>`[src]

`#[lang = "range_inclusive_new"]pub const fn new(start: Idx, end: Idx) -> RangeInclusive<Idx>ⓘNotable traits for RangeInclusive<A> impl<A> Iterator for RangeInclusive<A> where A: Step, type Item = A;`[src]1.27.0

`pub fn into_inner(self) -> (Idx, Idx)`[src]1.27.0

`impl<Idx> RangeInclusive<Idx> where Idx: PartialOrd<Idx>,` [src]

`pub fn contains<U>(&self, item: &U) -> bool where Idx: PartialOrd<U>, U: PartialOrd<Idx> + ?Sized,` [src]1.35.0

`pub fn is_empty(&self) -> bool`[src]1.47.0

`impl<Idx> Clone for RangeInclusive<Idx> where Idx: Clone,` [src]

`fn clone(&self) -> RangeInclusive<Idx>ⓘNotable traits for RangeInclusive<A> impl<A> Iterator for RangeInclusive<A> where A: Step, type Item = A;`[src]

`fn clone_from(&mut self, source: &Self)`[src]1.0.0

`impl<Idx> Debug for RangeInclusive<Idx> where Idx: Debug,` [src]

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

`impl<A> DoubleEndedIterator for RangeInclusive<A> where A: Step,` [src]

`fn next_back(&mut self) -> Option<A>`[src]

`fn nth_back(&mut self, n: usize) -> Option<A>`[src]

`fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Ok = B>, RangeInclusive<A>: Sized,` [src]

`fn rfold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> B, RangeInclusive<A>: Sized,` [src]

`fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,` [src]1.27.0

`impl<Idx> Eq for RangeInclusive<Idx> where Idx: Eq,` [src]

`impl ExactSizeIterator for RangeInclusive<u16>`[src]

`fn len(&self) -> usize`[src]1.0.0

`fn is_empty(&self) -> bool`[src]

`impl ExactSizeIterator for RangeInclusive<u8>`[src]

`fn len(&self) -> usize`[src]1.0.0

`fn is_empty(&self) -> bool`[src]

`impl ExactSizeIterator for RangeInclusive<i8>`[src]

`fn len(&self) -> usize`[src]1.0.0

`fn is_empty(&self) -> bool`[src]

`impl ExactSizeIterator for RangeInclusive<i16>`[src]

`fn len(&self) -> usize`[src]1.0.0

`fn is_empty(&self) -> bool`[src]

`impl<A> FusedIterator for RangeInclusive<A> where A: Step,` [src]

`impl<Idx> Hash for RangeInclusive<Idx> where Idx: Hash,` [src]

`fn hash<H>(&self, state: &mut H) where __H: Hasher,` [src]

`fn hash_slice<H>(data: &[Self], state: &mut H) where H: Hasher,` [src]1.3.0

`impl Index<RangeInclusive<usize>> for String`[src]

`type Output = str`

`fn index(&self, index: RangeInclusive<usize>) -> &str`[src]

`impl IndexMut<RangeInclusive<usize>> for String`[src]

`fn index_mut(&mut self, index: RangeInclusive<usize>) -> &mut str`[src]

`impl<A> Iterator for RangeInclusive<A> where A: Step,` [src]

`type Item = A`

`fn next(&mut self) -> Option<A>`[src]

`fn size_hint(&self) -> (usize, Option<usize>)`[src]

`fn nth(&mut self, n: usize) -> Option<A>`[src]

`fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> R, R: Try<Ok = B>, RangeInclusive<A>: Sized,` [src]

`fn fold<B, F>(self, init: B, f: F) -> B where F: FnMut(B, <RangeInclusive<A> as Iterator>::Item) -> B, RangeInclusive<A>: Sized,` [src]

`fn last(self) -> Option<A>`[src]

`fn min(self) -> Option<A>`[src]

`fn max(self) -> Option<A>`[src]

`fn count(self) -> usize`[src]1.0.0

`fn step_by(self, step: usize) -> StepBy<Self>ⓘNotable traits for StepBy<I> impl<I> Iterator for StepBy<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.28.0

`fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Chain<A, B> impl<A, B> Iterator for Chain<A, B> where A: Iterator, B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item; where U: IntoIterator<Item = Self::Item>,` [src]1.0.0

`fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘNotable traits for Zip<A, B> impl<A, B> Iterator for Zip<A, B> where A: Iterator, B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item); where U: IntoIterator,` [src]1.0.0

`fn map<B, F>(self, f: F) -> Map<Self, F>ⓘNotable traits for Map<I, F> impl<B, I, F> Iterator for Map<I, F> where F: FnMut(<I as Iterator>::Item) -> B, I: Iterator, type Item = B; where F: FnMut(Self::Item) -> B,` [src]1.0.0

`fn for_each<F>(self, f: F) where F: FnMut(Self::Item),` [src]1.21.0

`fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘNotable traits for Filter<I, P> impl<I, P> Iterator for Filter<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘNotable traits for FilterMap<I, F> impl<B, I, F> Iterator for FilterMap<I, F> where F: FnMut(<I as Iterator>::Item) -> Option<B>, I: Iterator, type Item = B; where F: FnMut(Self::Item) -> Option<B>,` [src]1.0.0

`fn enumerate(self) -> Enumerate<Self>ⓘNotable traits for Enumerate<I> impl<I> Iterator for Enumerate<I> where I: Iterator, type Item = (usize, <I as Iterator>::Item);`[src]1.0.0

`fn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I> impl<I> Iterator for Peekable<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.0.0

`fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘNotable traits for SkipWhile<I, P> impl<I, P> Iterator for SkipWhile<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘNotable traits for TakeWhile<I, P> impl<I, P> Iterator for TakeWhile<I, P> where I: Iterator, P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item; where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘNotable traits for MapWhile<I, P> impl<B, I, P> Iterator for MapWhile<I, P> where I: Iterator, P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B; where P: FnMut(Self::Item) -> Option<B>,` [src]

`fn skip(self, n: usize) -> Skip<Self>ⓘNotable traits for Skip<I> impl<I> Iterator for Skip<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.0.0

`fn take(self, n: usize) -> Take<Self>ⓘNotable traits for Take<I> impl<I> Iterator for Take<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.0.0

`fn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I> impl<I> Iterator for Fuse<I> where I: Iterator, type Item = <I as Iterator>::Item;`[src]1.0.0

`fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F> impl<I, F> Iterator for Inspect<I, F> where F: FnMut(&<I as Iterator>::Item), I: Iterator, type Item = <I as Iterator>::Item; where F: FnMut(&Self::Item),` [src]1.0.0

`fn partition<B, F>(self, f: F) -> (B, B) where B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where P: FnMut(&T) -> bool, Self: DoubleEndedIterator<Item = &'a mut T>, T: 'a,` [src]

`fn is_partitioned<P>(self, predicate: P) -> bool where P: FnMut(Self::Item) -> bool,` [src]

`fn try_for_each<F, R>(&mut self, f: F) -> R where F: FnMut(Self::Item) -> R, R: Try<Ok = ()>,` [src]1.27.0

`fn fold_first<F>(self, f: F) -> Option<Self::Item> where F: FnMut(Self::Item, Self::Item) -> Self::Item,` [src]

`fn all<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn any<F>(&mut self, f: F) -> bool where F: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where P: FnMut(&Self::Item) -> bool,` [src]1.0.0

`fn find_map<B, F>(&mut self, f: F) -> Option<B> where F: FnMut(Self::Item) -> Option<B>,` [src]1.30.0

`fn try_find<F, R>( &mut self, f: F ) -> Result<Option<Self::Item>, <R as Try>::Error> where F: FnMut(&Self::Item) -> R, R: Try<Ok = bool>,` [src]

`fn position<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool,` [src]1.0.0

`fn rposition<P>(&mut self, predicate: P) -> Option<usize> where P: FnMut(Self::Item) -> bool, Self: ExactSizeIterator + DoubleEndedIterator,` [src]1.0.0

`fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where B: Ord, F: FnMut(&Self::Item) -> B,` [src]1.6.0

`fn max_by<F>(self, compare: F) -> Option<Self::Item> where F: FnMut(&Self::Item, &Self::Item) -> Ordering,` [src]1.15.0