1.0.0[−][src]Struct std::ops::Range
A (half-open) range bounded inclusively below and exclusively above
(start..end).
The Range start..end contains all values with x >= start and
x < end. It is empty unless start < end.
Examples
assert_eq!((3..5), std::ops::Range { start: 3, end: 5 }); assert_eq!(3 + 4 + 5, (3..6).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 ]); // Range assert_eq!(arr[1..=3], [ 1,2,3 ]);Run
Fields
start: IdxThe lower bound of the range (inclusive).
end: IdxThe upper bound of the range (exclusive).
Methods
impl<Idx> Range<Idx> where
Idx: PartialOrd<Idx>, [src]
Idx: PartialOrd<Idx>,
pub fn contains<U>(&self, item: &U) -> bool where
Idx: PartialOrd<U>,
U: PartialOrd<Idx> + ?Sized, 1.35.0[src]
Idx: PartialOrd<U>,
U: PartialOrd<Idx> + ?Sized,
Returns true if item is contained in the range.
Examples
use std::f32; assert!(!(3..5).contains(&2)); assert!( (3..5).contains(&3)); assert!( (3..5).contains(&4)); assert!(!(3..5).contains(&5)); assert!(!(3..3).contains(&3)); assert!(!(3..2).contains(&3)); assert!( (0.0..1.0).contains(&0.5)); assert!(!(0.0..1.0).contains(&f32::NAN)); assert!(!(0.0..f32::NAN).contains(&0.5)); assert!(!(f32::NAN..1.0).contains(&0.5));Run
pub fn is_empty(&self) -> bool[src]
🔬 This is a nightly-only experimental API. (range_is_empty #48111)
recently added
Returns true if the range contains no items.
Examples
#![feature(range_is_empty)] assert!(!(3..5).is_empty()); assert!( (3..3).is_empty()); assert!( (3..2).is_empty());Run
The range is empty if either side is incomparable:
#![feature(range_is_empty)] use std::f32::NAN; assert!(!(3.0..5.0).is_empty()); assert!( (3.0..NAN).is_empty()); assert!( (NAN..5.0).is_empty());Run
Trait Implementations
impl<Idx> Clone for Range<Idx> where
Idx: Clone, [src]
Idx: Clone,
impl<Idx> Debug for Range<Idx> where
Idx: Debug, [src]
Idx: Debug,
impl<A> DoubleEndedIterator for Range<A> where
A: Step, [src]
A: Step,
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, Self::Item) -> R,
R: Try<Ok = B>, 1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn rfold<B, F>(self, accum: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, 1.27.0[src]
F: FnMut(B, Self::Item) -> B,
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, 1.27.0[src]
P: FnMut(&Self::Item) -> bool,
impl<Idx> Eq for Range<Idx> where
Idx: Eq, [src]
Idx: Eq,
impl ExactSizeIterator for Range<isize>[src]
impl ExactSizeIterator for Range<i8>[src]
impl ExactSizeIterator for Range<u16>[src]
impl ExactSizeIterator for Range<i16>[src]
impl ExactSizeIterator for Range<i32>[src]
impl ExactSizeIterator for Range<u8>[src]
impl ExactSizeIterator for Range<usize>[src]
impl ExactSizeIterator for Range<u32>[src]
impl<A> FusedIterator for Range<A> where
A: Step, 1.26.0[src]
A: Step,
impl<Idx> Hash for Range<Idx> where
Idx: Hash, [src]
Idx: Hash,
fn hash<__H>(&self, state: &mut __H) where
__H: Hasher, [src]
__H: Hasher,
fn hash_slice<H>(data: &[Self], state: &mut H) where
H: Hasher, 1.3.0[src]
H: Hasher,
impl Index<Range<usize>> for String[src]
type Output = str
The returned type after indexing.
fn index(&self, index: Range<usize>) -> &str[src]
impl IndexMut<Range<usize>> for String1.3.0[src]
impl<A> Iterator for Range<A> where
A: Step, [src]
A: Step,
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 last(self) -> Option<A>[src]
fn min(self) -> Option<A>[src]
fn max(self) -> Option<A>[src]
fn count(self) -> usize[src]
fn step_by(self, step: usize) -> StepBy<Self>1.28.0[src]
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>, [src]
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator, [src]
U: IntoIterator,
fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B, [src]
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item), 1.21.0[src]
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>, [src]
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self>[src]
fn peekable(self) -> Peekable<Self>[src]
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
P: FnMut(&Self::Item) -> bool,
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool, [src]
P: FnMut(&Self::Item) -> bool,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>, [src]
P: FnMut(Self::Item) -> Option<B>,
fn skip(self, n: usize) -> Skip<Self>[src]
fn take(self, n: usize) -> Take<Self>[src]
fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>, [src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator, [src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator, 1.29.0[src]
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self>[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item), [src]
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self[src]
#[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]
B: FromIterator<Self::Item>,
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool, [src]
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
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]
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a,
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool, [src]
P: FnMut(Self::Item) -> bool,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, 1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>, 1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, [src]
F: FnMut(B, Self::Item) -> B,
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, [src]
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, [src]
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, [src]
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>, 1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
fn try_find<F, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>, [src]
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool, [src]
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator, [src]
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, 1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, 1.6.0[src]
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, 1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator, [src]
Self: DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>, [src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy, 1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone, [src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
fn cycle(self) -> Cycle<Self> where
Self: Clone, [src]
Self: Clone,
fn sum<S>(self) -> S where
S: Sum<Self::Item>, 1.11.0[src]
S: Sum<Self::Item>,
fn product<P>(self) -> P where
P: Product<Self::Item>, 1.11.0[src]
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord, 1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator, [src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
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]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator, [src]
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, 1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>, [src]
Self::Item: PartialOrd<Self::Item>,
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>, [src]
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
impl<Idx> PartialEq<Range<Idx>> for Range<Idx> where
Idx: PartialEq<Idx>, [src]
Idx: PartialEq<Idx>,
impl<'_, T> RangeBounds<T> for Range<&'_ T>1.28.0[src]
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, 1.35.0[src]
T: PartialOrd<U>,
U: PartialOrd<T> + ?Sized,
impl<T> RangeBounds<T> for Range<T>1.28.0[src]
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, 1.35.0[src]
T: PartialOrd<U>,
U: PartialOrd<T> + ?Sized,
impl<T> SliceIndex<[T]> for Range<usize>1.15.0[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: &[T]) -> &[T][src]
unsafe fn get_unchecked_mut(self, slice: &mut [T]) -> &mut [T][src]
fn index(self, slice: &[T]) -> &[T][src]
fn index_mut(self, slice: &mut [T]) -> &mut [T][src]
impl SliceIndex<str> for Range<usize>1.20.0[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).
This operation is O(1).
Prior to 1.20.0, these indexing operations were still supported by
direct implementation of Index and IndexMut.
Panics
Panics if begin or end does not point to the starting byte offset of
a character (as defined by is_char_boundary), if begin > end, or if
end > len.
Examples
let s = "Löwe 老虎 Léopard"; assert_eq!(&s[0 .. 1], "L"); assert_eq!(&s[1 .. 9], "öwe 老"); // these will panic: // byte 2 lies within `ö`: // &s[2 ..3]; // byte 8 lies within `老` // &s[1 .. 8]; // byte 100 is outside the string // &s[3 .. 100];Run
type Output = str
The output type returned by methods.
fn get(self, slice: &str) -> Option<&<Range<usize> as SliceIndex<str>>::Output>[src]
fn get_mut(
self,
slice: &mut str
) -> Option<&mut <Range<usize> as SliceIndex<str>>::Output>[src]
self,
slice: &mut str
) -> Option<&mut <Range<usize> as SliceIndex<str>>::Output>
unsafe fn get_unchecked(
self,
slice: &str
) -> &<Range<usize> as SliceIndex<str>>::Output[src]
self,
slice: &str
) -> &<Range<usize> as SliceIndex<str>>::Output
unsafe fn get_unchecked_mut(
self,
slice: &mut str
) -> &mut <Range<usize> as SliceIndex<str>>::Output[src]
self,
slice: &mut str
) -> &mut <Range<usize> as SliceIndex<str>>::Output
fn index(self, slice: &str) -> &<Range<usize> as SliceIndex<str>>::Output[src]
fn index_mut(
self,
slice: &mut str
) -> &mut <Range<usize> as SliceIndex<str>>::Output[src]
self,
slice: &mut str
) -> &mut <Range<usize> as SliceIndex<str>>::Output
impl<Idx> StructuralEq for Range<Idx>[src]
impl<Idx> StructuralPartialEq for Range<Idx>[src]
impl TrustedLen for Range<u64>[src]
impl TrustedLen for Range<i128>[src]
impl TrustedLen for Range<u32>[src]
impl TrustedLen for Range<i64>[src]
impl TrustedLen for Range<isize>[src]
impl TrustedLen for Range<i16>[src]
impl TrustedLen for Range<i32>[src]
impl TrustedLen for Range<i8>[src]
impl TrustedLen for Range<u8>[src]
impl TrustedLen for Range<usize>[src]
impl TrustedLen for Range<u128>[src]
impl TrustedLen for Range<u16>[src]
Auto Trait Implementations
impl<Idx> RefUnwindSafe for Range<Idx> where
Idx: RefUnwindSafe,
Idx: RefUnwindSafe,
impl<Idx> Send for Range<Idx> where
Idx: Send,
Idx: Send,
impl<Idx> Sync for Range<Idx> where
Idx: Sync,
Idx: Sync,
impl<Idx> Unpin for Range<Idx> where
Idx: Unpin,
Idx: Unpin,
impl<Idx> UnwindSafe for Range<Idx> where
Idx: UnwindSafe,
Idx: UnwindSafe,
Blanket Implementations
impl<T> Any for T where
T: 'static + ?Sized, [src]
T: 'static + ?Sized,
impl<T> Borrow<T> for T where
T: ?Sized, [src]
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
U: From<T>,
impl<I> IntoIterator for I where
I: Iterator, [src]
I: Iterator,
type Item = <I as Iterator>::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]
T: Clone,
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<U> for T where
U: Into<T>, [src]
U: Into<T>,
type Error = Infallible
The 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]
U: TryFrom<T>,