#[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.
assert_eq!((2..), std::ops::RangeFrom { start: 2 }); assert_eq!(2 + 3 + 4, (2..).take(3).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]); // RangeFrom assert_eq!(arr[1.. 3], [ 1,2 ]); assert_eq!(arr[1..=3], [ 1,2,3 ]);
start: Idx
The lower bound of the range (inclusive).
impl<Idx> RangeFrom<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.
impl<Idx> Clone for RangeFrom<Idx> where
Idx: Clone,
[src]
impl<Idx> Debug for RangeFrom<Idx> where
Idx: Debug,
[src]
impl<Idx> Eq for RangeFrom<Idx> where
Idx: Eq,
[src]
impl<A> FusedIterator for RangeFrom<A> where
A: Step,
[src]1.26.0
impl<Idx> Hash for RangeFrom<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<RangeFrom<usize>> for String
[src]
type Output = str
The returned type after indexing.
fn index(&self, index: RangeFrom<usize>) -> &str
[src]
impl Index<RangeFrom<usize>> for CStr
[src]1.47.0
type Output = CStr
The returned type after indexing.
fn index(&self, index: RangeFrom<usize>) -> &CStr
[src]
impl IndexMut<RangeFrom<usize>> for String
[src]1.3.0
impl<A> Iterator for RangeFrom<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 count(self) -> usize
[src]
fn last(self) -> Option<Self::Item>
[src]
fn step_by(self, step: usize) -> StepBy<Self>ⓘ
[src]1.28.0
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>ⓘ where
U: IntoIterator<Item = Self::Item>,
[src]
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>ⓘ where
U: IntoIterator,
[src]
fn map<B, F>(self, f: F) -> Map<Self, F>ⓘ where
F: FnMut(Self::Item) -> B,
[src]
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>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>ⓘ where
F: FnMut(Self::Item) -> Option<B>,
[src]
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]
fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>ⓘ where
P: FnMut(&Self::Item) -> bool,
[src]
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>ⓘ where
P: FnMut(Self::Item) -> Option<B>,
[src]
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]
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>ⓘ where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
[src]
fn flatten(self) -> Flatten<Self>ⓘ where
Self::Item: IntoIterator,
[src]1.29.0
fn fuse(self) -> Fuse<Self>ⓘ
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘ where
F: FnMut(&Self::Item),
[src]
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]
#[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]
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
[src]
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_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
[src]1.27.0
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<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
[src]
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]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
[src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
[src]
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]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator,
[src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
[src]
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>ⓘ where
Self: DoubleEndedIterator,
[src]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
[src]
fn copied<'a, T>(self) -> Copied<Self>ⓘ where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
[src]1.36.0
fn cloned<'a, T>(self) -> Cloned<Self>ⓘ where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
[src]
fn cycle(self) -> Cycle<Self>ⓘ where
Self: Clone,
[src]
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<RangeFrom<Idx>> for RangeFrom<Idx> where
Idx: PartialEq<Idx>,
[src]
impl<T> RangeBounds<T> for RangeFrom<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 RangeFrom<&'_ 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 RangeFrom<usize>
[src]1.15.0
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>
[src]1.20.0
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 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<&<RangeFrom<usize> as SliceIndex<str>>::Output>
[src]
fn get_mut(
self,
slice: &mut str
) -> Option<&mut <RangeFrom<usize> as SliceIndex<str>>::Output>
[src]
unsafe fn get_unchecked(
self,
slice: *const str
) -> *const <RangeFrom<usize> as SliceIndex<str>>::Output
[src]
unsafe fn get_unchecked_mut(
self,
slice: *mut str
) -> *mut <RangeFrom<usize> as SliceIndex<str>>::Output
[src]
fn index(self, slice: &str) -> &<RangeFrom<usize> as SliceIndex<str>>::Outputⓘ
[src]
fn index_mut(
self,
slice: &mut str
) -> &mut <RangeFrom<usize> as SliceIndex<str>>::Outputⓘ
[src]
impl<Idx> StructuralEq for RangeFrom<Idx>
[src]
impl<Idx> StructuralPartialEq for RangeFrom<Idx>
[src]
impl<A> TrustedLen for RangeFrom<A> where
A: Step,
[src]
impl<Idx> RefUnwindSafe for RangeFrom<Idx> where
Idx: RefUnwindSafe,
impl<Idx> Send for RangeFrom<Idx> where
Idx: Send,
impl<Idx> Sync for RangeFrom<Idx> where
Idx: Sync,
impl<Idx> Unpin for RangeFrom<Idx> where
Idx: Unpin,
impl<Idx> UnwindSafe for RangeFrom<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>::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<U> 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<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.RangeFrom.html