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<usize>[src]
impl ExactSizeIterator for Range<i8>[src]
impl ExactSizeIterator for Range<isize>[src]
impl ExactSizeIterator for Range<u32>[src]
impl ExactSizeIterator for Range<u16>[src]
impl ExactSizeIterator for Range<u8>[src]
impl ExactSizeIterator for Range<i32>[src]
impl ExactSizeIterator for Range<i16>[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<u16>[src]
impl TrustedLen for Range<i32>[src]
impl TrustedLen for Range<i8>[src]
impl TrustedLen for Range<i128>[src]
impl TrustedLen for Range<isize>[src]
impl TrustedLen for Range<i64>[src]
impl TrustedLen for Range<u128>[src]
impl TrustedLen for Range<usize>[src]
impl TrustedLen for Range<u8>[src]
impl TrustedLen for Range<i16>[src]
impl TrustedLen for Range<u32>[src]
impl TrustedLen for Range<u64>[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>,