#[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.
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
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.
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.
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).
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.
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.
assert_eq!((3..=5).into_inner(), (3, 5));
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
Returns true if item is contained in the range.
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.
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());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]
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]
impl ExactSizeIterator for RangeInclusive<u8>[src]
impl ExactSizeIterator for RangeInclusive<i8>[src]
impl ExactSizeIterator for RangeInclusive<i16>[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 = strThe 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 = AThe 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<B>(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<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
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<B>,
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<P>(self) -> P where
P: Product<Self::Item>, [src]1.11.0
fn cmp<I>(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, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator, [src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator, [src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, [src]1.5.0
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator, [src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, [src]1.5.0
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::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<U>(&self, item: &U) -> bool where
T: PartialOrd<U>,
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<U>(&self, item: &U) -> bool where
T: PartialOrd<U>,
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 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 = strThe 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]
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, impl<T> Any for T where
T: 'static + ?Sized, [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]
impl<T, U> Into<U> for T where
U: From<T>, [src]
impl<I> IntoIterator for I where
I: Iterator, [src]
type Item = <I as Iterator>::ItemThe type of the elements being iterated over.
type IntoIter = IWhich 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 = TThe resulting type after obtaining ownership.
fn to_owned(&self) -> T[src]
fn clone_into(&self, target: &mut T)[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
type Error = InfallibleThe type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [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