Struct core::ops::RangeFrom 1.0.0[−][src]
#[lang = "RangeFrom"]pub struct RangeFrom<Idx> { pub start: Idx, }
A range only bounded inclusively below (start..
).
The RangeFrom
start..
contains all values with x >= start
.
Note: Overflow in the Iterator
implementation (when the contained
data type reaches its numerical limit) is allowed to panic, wrap, or
saturate. This behavior is defined by the implementation of the Step
trait. For primitive integers, this follows the normal rules, and respects
the overflow checks profile (panic in debug, wrap in release). Note also
that overflow happens earlier than you might assume: the overflow happens
in the call to next
that yields the maximum value, as the range must be
set to a state to yield the next value.
Examples
The start..
syntax is a RangeFrom
:
assert_eq!((2..), std::ops::RangeFrom { start: 2 }); assert_eq!(2 + 3 + 4, (2..).take(3).sum());Run
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]); // This is a `RangeFrom` assert_eq!(arr[1.. 3], [ 1, 2 ]); assert_eq!(arr[1..=3], [ 1, 2, 3 ]);Run
Fields
start: Idx
The lower bound of the range (inclusive).
Implementations
impl<Idx: PartialOrd<Idx>> RangeFrom<Idx>
[src]
pub fn contains<U: ?Sized>(&self, item: &U) -> bool where
Idx: PartialOrd<U>,
U: PartialOrd<Idx>,
1.35.0[src]
Idx: PartialOrd<U>,
U: PartialOrd<Idx>,
Trait Implementations
impl<Idx: Clone> Clone for RangeFrom<Idx>
[src]
fn clone(&self) -> RangeFrom<Idx>ⓘ
[src]
fn clone_from(&mut self, source: &Self)
[src]
impl<Idx: Debug> Debug for RangeFrom<Idx>
[src]
impl<Idx: Eq> Eq for RangeFrom<Idx>
[src]
impl<A: Step> FusedIterator for RangeFrom<A>
1.26.0[src]
impl<Idx: Hash> Hash for RangeFrom<Idx>
[src]
fn hash<__H: Hasher>(&self, state: &mut __H)
[src]
fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) where
Self: Sized,
1.3.0[src]
Self: Sized,
impl<A: Step> Iterator for RangeFrom<A>
[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 count(self) -> usize where
Self: Sized,
[src]
Self: Sized,
fn last(self) -> Option<Self::Item> where
Self: Sized,
[src]
Self: Sized,
fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn step_by(self, step: usize) -> StepBy<Self>ⓘ where
Self: Sized,
1.28.0[src]
Self: Sized,
fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter>ⓘ where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
[src]
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter>ⓘ where
Self: Sized,
U: IntoIterator,
[src]
Self: Sized,
U: IntoIterator,
fn intersperse(self, separator: Self::Item) -> Intersperse<Self>ⓘNotable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
I::Item: Clone, type Item = I::Item;
where
Self: Sized,
Self::Item: Clone,
[src]
Notable traits for Intersperse<I>
impl<I> Iterator for Intersperse<I> where
I: Iterator,
I::Item: Clone, type Item = I::Item;
Self: Sized,
Self::Item: Clone,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>ⓘNotable traits for IntersperseWith<I, G>
impl<I, G> Iterator for IntersperseWith<I, G> where
I: Iterator,
G: FnMut() -> I::Item, type Item = I::Item;
where
Self: Sized,
G: FnMut() -> Self::Item,
[src]
Notable traits for IntersperseWith<I, G>
impl<I, G> Iterator for IntersperseWith<I, G> where
I: Iterator,
G: FnMut() -> I::Item, type Item = I::Item;
Self: Sized,
G: FnMut() -> Self::Item,
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘ where
Self: Sized,
F: FnMut(Self::Item) -> B,
[src]
Self: Sized,
F: FnMut(Self::Item) -> B,
fn for_each<F>(self, f: F) where
Self: Sized,
F: FnMut(Self::Item),
1.21.0[src]
Self: Sized,
F: FnMut(Self::Item),
fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘ where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘ where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn peekable(self) -> Peekable<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>ⓘ where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
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,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘ where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
[src]
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn skip(self, n: usize) -> Skip<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn take(self, n: usize) -> Take<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
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>,
[src]
Self: Sized,
F: FnMut(&mut St, Self::Item) -> Option<B>,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘ where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
[src]
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flatten(self) -> Flatten<Self>ⓘ where
Self: Sized,
Self::Item: IntoIterator,
1.29.0[src]
Self: Sized,
Self::Item: IntoIterator,
fn fuse(self) -> Fuse<Self>ⓘ where
Self: Sized,
[src]
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘ where
Self: Sized,
F: FnMut(&Self::Item),
[src]
Self: Sized,
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self where
Self: Sized,
[src]
Self: Sized,
#[must_use = "if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B: FromIterator<Self::Item>>(self) -> B where
Self: Sized,
[src]
Self: Sized,
fn partition<B, F>(self, f: F) -> (B, B) where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition_in_place<'a, T: 'a, P>(self, predicate: P) -> usize where
Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
[src]
Self: Sized + DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
fn is_partitioned<P>(self, predicate: P) -> bool where
Self: Sized,
P: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn try_for_each<F, R>(&mut self, f: F) -> R where
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
fn fold<B, F>(self, init: B, f: F) -> B where
Self: Sized,
F: FnMut(B, Self::Item) -> B,
[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn reduce<F>(self, f: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
1.51.0[src]
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn all<F>(&mut self, f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn try_find<F, R>(&mut self, f: F) -> Result<Option<Self::Item>, R::Error> where
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
[src]
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
Self: Sized,
P: FnMut(Self::Item) -> bool,
[src]
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
[src]
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
Self: Sized,
Self::Item: Ord,
[src]
Self: Sized,
Self::Item: Ord,
fn max_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by_key<B: Ord, F>(self, f: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item) -> B,
1.6.0[src]
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn rev(self) -> Rev<Self>ⓘ where
Self: Sized + DoubleEndedIterator,
[src]
Self: Sized + DoubleEndedIterator,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
[src]
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn copied<'a, T: 'a>(self) -> Copied<Self>ⓘ where
Self: Sized + Iterator<Item = &'a T>,
T: Copy,
1.36.0[src]
Self: Sized + Iterator<Item = &'a T>,
T: Copy,
fn cloned<'a, T: 'a>(self) -> Cloned<Self>ⓘ where
Self: Sized + Iterator<Item = &'a T>,
T: Clone,
[src]
Self: Sized + Iterator<Item = &'a T>,
T: Clone,
fn cycle(self) -> Cycle<Self>ⓘ where
Self: Sized + Clone,
[src]
Self: Sized + Clone,
fn sum<S>(self) -> S where
Self: Sized,
S: Sum<Self::Item>,
1.11.0[src]
Self: Sized,
S: Sum<Self::Item>,
fn product<P>(self) -> P where
Self: Sized,
P: Product<Self::Item>,
1.11.0[src]
Self: Sized,
P: Product<Self::Item>,
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Self: Sized,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
Self: Sized,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Ordering,
[src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Ordering,
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
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>,
[src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> Option<Ordering>,
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> bool,
[src]
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, I::Item) -> bool,
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<I::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<I::Item>,
Self: Sized,
fn is_sorted(self) -> bool where
Self: Sized,
Self::Item: PartialOrd,
[src]
Self: Sized,
Self::Item: PartialOrd,
fn is_sorted_by<F>(self, compare: F) -> bool where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd,
[src]
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd,
impl<Idx: PartialEq> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx>
[src]
impl<T> RangeBounds<T> for RangeFrom<T>
1.28.0[src]
fn start_bound(&self) -> Bound<&T>
[src]
fn end_bound(&self) -> Bound<&T>
[src]
fn contains<U: ?Sized>(&self, item: &U) -> bool where
T: PartialOrd<U>,
U: PartialOrd<T>,
1.35.0[src]
T: PartialOrd<U>,
U: PartialOrd<T>,
impl<T> RangeBounds<T> for RangeFrom<&T>
1.28.0[src]
fn start_bound(&self) -> Bound<&T>
[src]
fn end_bound(&self) -> Bound<&T>
[src]
fn contains<U: ?Sized>(&self, item: &U) -> bool where
T: PartialOrd<U>,
U: PartialOrd<T>,
1.35.0[src]
T: PartialOrd<U>,
U: PartialOrd<T>,
impl<T> SliceIndex<[T]> for RangeFrom<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: *const [T]) -> *const [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 RangeFrom<usize>
1.20.0[src]
Implements substring slicing with syntax &self[begin ..]
or &mut self[begin ..]
.
Returns a slice of the given string from the byte range [begin
,
len
). Equivalent to &self[begin .. len]
or &mut self[begin .. len]
.
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
does not point to the starting byte offset of
a character (as defined by is_char_boundary
), or if begin > len
.
type Output = str
The output type returned by methods.
fn get(self, slice: &str) -> Option<&Self::Output>
[src]
fn get_mut(self, slice: &mut str) -> Option<&mut Self::Output>
[src]
unsafe fn get_unchecked(self, slice: *const str) -> *const Self::Output
[src]
unsafe fn get_unchecked_mut(self, slice: *mut str) -> *mut Self::Output
[src]
fn index(self, slice: &str) -> &Self::Output
[src]
fn index_mut(self, slice: &mut str) -> &mut Self::Output
[src]
impl<Idx> StructuralEq for RangeFrom<Idx>
[src]
impl<Idx> StructuralPartialEq for RangeFrom<Idx>
[src]
impl<A: Step> TrustedLen for RangeFrom<A>
[src]
Auto Trait Implementations
impl<Idx> Send for RangeFrom<Idx> where
Idx: Send,
Idx: Send,
impl<Idx> Sync for RangeFrom<Idx> where
Idx: Sync,
Idx: Sync,
impl<Idx> Unpin for RangeFrom<Idx> where
Idx: Unpin,
Idx: Unpin,
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,
pub 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<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.
pub fn try_from(U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,