pub struct RangeFrom<Idx> {
pub start: Idx,
}
Expand description
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());
Runlet 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 ]);
RunFields
start: Idx
The lower bound of the range (inclusive).
Implementations
sourceimpl<Idx> RangeFrom<Idx>where
Idx: PartialOrd<Idx>,
impl<Idx> RangeFrom<Idx>where
Idx: PartialOrd<Idx>,
1.35.0 · sourcepub fn contains<U>(&self, item: &U) -> boolwhere
Idx: PartialOrd<U>,
U: PartialOrd<Idx> + ?Sized,
pub fn contains<U>(&self, item: &U) -> boolwhere
Idx: PartialOrd<U>,
U: PartialOrd<Idx> + ?Sized,
Trait Implementations
sourceimpl<A> Iterator for RangeFrom<A>where
A: Step,
impl<A> Iterator for RangeFrom<A>where
A: Step,
type Item = A
type Item = A
sourcefn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
sourcefn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>
iter_next_chunk
#98326)N
values. Read moresourcefn count(self) -> usize
fn count(self) -> usize
sourcefn last(self) -> Option<Self::Item>
fn last(self) -> Option<Self::Item>
sourcefn advance_by(&mut self, n: usize) -> Result<(), usize>
fn advance_by(&mut self, n: usize) -> Result<(), usize>
iter_advance_by
#77404)n
elements. Read more1.28.0 · sourcefn 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;
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;
I: Iterator, type Item = <I as Iterator>::Item;
sourcefn 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>,
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>,
A: Iterator,
B: Iterator<Item = <A as Iterator>::Item>, type Item = <A as Iterator>::Item;
sourcefn 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,
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,
A: Iterator,
B: Iterator, type Item = (<A as Iterator>::Item, <B as Iterator>::Item);
sourcefn 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 as Iterator>::Item, type Item = <I as Iterator>::Item;
where
G: FnMut() -> Self::Item,
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 as Iterator>::Item, type Item = <I as Iterator>::Item;
where
G: FnMut() -> Self::Item,
I: Iterator,
G: FnMut() -> <I as Iterator>::Item, type Item = <I as Iterator>::Item;
iter_intersperse
#79524)separator
between adjacent items of the original iterator. Read moresourcefn 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: FnMut(Self::Item) -> B,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
where
F: FnMut(Self::Item) -> B,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> B, type Item = B;
1.21.0 · sourcefn for_each<F>(self, f: F)where
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where
F: FnMut(Self::Item),
sourcefn 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,
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,
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
sourcefn 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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
where
F: FnMut(Self::Item) -> Option<B>,
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
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
where
F: FnMut(Self::Item) -> Option<B>,
I: Iterator,
F: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
sourcefn 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);
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);
I: Iterator, type Item = (usize, <I as Iterator>::Item);
sourcefn peekable(self) -> Peekable<Self>ⓘNotable traits for Peekable<I>impl<I> Iterator for Peekable<I>where
I: Iterator, type Item = <I as Iterator>::Item;
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;
I: Iterator, type Item = <I as Iterator>::Item;
sourcefn 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,
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,
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
sourcefn 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,
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,
I: Iterator,
P: FnMut(&<I as Iterator>::Item) -> bool, type Item = <I as Iterator>::Item;
1.57.0 · sourcefn 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>,
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>,
I: Iterator,
P: FnMut(<I as Iterator>::Item) -> Option<B>, type Item = B;
sourcefn 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;
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;
I: Iterator, type Item = <I as Iterator>::Item;
n
elements. Read moresourcefn 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;
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;
I: Iterator, type Item = <I as Iterator>::Item;
n
elements, or fewer
if the underlying iterator ends sooner. Read moresourcefn 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
I: Iterator,
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>, type Item = B;
where
F: FnMut(&mut St, Self::Item) -> Option<B>,
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
I: Iterator,
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>, type Item = B;
where
F: FnMut(&mut St, Self::Item) -> Option<B>,
I: Iterator,
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>, type Item = B;
sourcefn 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
I: Iterator,
U: IntoIterator,
F: FnMut(<I as Iterator>::Item) -> U, type Item = <U as IntoIterator>::Item;
where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
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
I: Iterator,
U: IntoIterator,
F: FnMut(<I as Iterator>::Item) -> U, type Item = <U as IntoIterator>::Item;
where
U: IntoIterator,
F: FnMut(Self::Item) -> U,
I: Iterator,
U: IntoIterator,
F: FnMut(<I as Iterator>::Item) -> U, type Item = <U as IntoIterator>::Item;
sourcefn fuse(self) -> Fuse<Self>ⓘNotable traits for Fuse<I>impl<I> Iterator for Fuse<I>where
I: Iterator, type Item = <I as Iterator>::Item;
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;
I: Iterator, type Item = <I as Iterator>::Item;
sourcefn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>impl<I, F> Iterator for Inspect<I, F>where
I: Iterator,
F: FnMut(&<I as Iterator>::Item), type Item = <I as Iterator>::Item;
where
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>impl<I, F> Iterator for Inspect<I, F>where
I: Iterator,
F: FnMut(&<I as Iterator>::Item), type Item = <I as Iterator>::Item;
where
F: FnMut(&Self::Item),
I: Iterator,
F: FnMut(&<I as Iterator>::Item), type Item = <I as Iterator>::Item;
sourcefn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
sourcefn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
iter_collect_into
#94780)sourcefn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
sourcefn is_partitioned<P>(self, predicate: P) -> boolwhere
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere
P: FnMut(Self::Item) -> bool,
iter_is_partitioned
#62544)true
precede all those that return false
. Read more1.27.0 · sourcefn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
1.27.0 · sourcefn try_for_each<F, R>(&mut self, f: F) -> Rwhere
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
sourcefn fold<B, F>(self, init: B, f: F) -> Bwhere
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> Bwhere
F: FnMut(B, Self::Item) -> B,
1.51.0 · sourcefn reduce<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
sourcefn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
F: FnMut(Self::Item, Self::Item) -> R,
R: Try<Output = Self::Item>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
#87053)sourcefn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
sourcefn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere
F: FnMut(Self::Item) -> bool,
sourcefn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
P: FnMut(&Self::Item) -> bool,
1.30.0 · sourcefn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where
F: FnMut(Self::Item) -> Option<B>,
sourcefn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
F: FnMut(&Self::Item) -> R,
R: Try<Output = bool>,
<R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
#63178)sourcefn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where
P: FnMut(Self::Item) -> bool,
1.6.0 · sourcefn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn max_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · sourcefn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
F: FnMut(&Self::Item) -> B,
1.15.0 · sourcefn min_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
sourcefn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>,
1.36.0 · sourcefn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>impl<'a, I, T> Iterator for Copied<I>where
T: 'a + Copy,
I: Iterator<Item = &'a T>, type Item = T;
where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>impl<'a, I, T> Iterator for Copied<I>where
T: 'a + Copy,
I: Iterator<Item = &'a T>, type Item = T;
where
T: 'a + Copy,
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
I: Iterator<Item = &'a T>, type Item = T;
sourcefn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>impl<'a, I, T> Iterator for Cloned<I>where
T: 'a + Clone,
I: Iterator<Item = &'a T>, type Item = T;
where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>impl<'a, I, T> Iterator for Cloned<I>where
T: 'a + Clone,
I: Iterator<Item = &'a T>, type Item = T;
where
T: 'a + Clone,
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
I: Iterator<Item = &'a T>, type Item = T;
sourcefn 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,
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,
I: Clone + Iterator, type Item = <I as Iterator>::Item;
sourcefn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>ⓘNotable traits for ArrayChunks<I, N>impl<I, const N: usize> Iterator for ArrayChunks<I, N>where
I: Iterator, type Item = [<I as Iterator>::Item; N];
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>ⓘNotable traits for ArrayChunks<I, N>impl<I, const N: usize> Iterator for ArrayChunks<I, N>where
I: Iterator, type Item = [<I as Iterator>::Item; N];
I: Iterator, type Item = [<I as Iterator>::Item; N];
iter_array_chunks
#100450)N
elements of the iterator at a time. Read more1.11.0 · sourcefn sum<S>(self) -> Swhere
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere
S: Sum<Self::Item>,
1.11.0 · sourcefn product<P>(self) -> Pwhere
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere
P: Product<Self::Item>,
sourcefn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by
#64295)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · sourcefn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
sourcefn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
#64295)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · sourcefn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
sourcefn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
#64295)1.5.0 · sourcefn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0 · sourcefn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
less than those of another. Read more1.5.0 · sourcefn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · sourcefn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · sourcefn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Iterator
are lexicographically
greater than or equal to those of another. Read moresourcefn is_sorted_by<F>(self, compare: F) -> boolwhere
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
#53485)sourcefn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
is_sorted
#53485)sourceimpl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx>where
Idx: PartialEq<Idx>,
impl<Idx> PartialEq<RangeFrom<Idx>> for RangeFrom<Idx>where
Idx: PartialEq<Idx>,
1.28.0 · sourceimpl<T> RangeBounds<T> for RangeFrom<&T>
impl<T> RangeBounds<T> for RangeFrom<&T>
1.28.0 · sourceimpl<T> RangeBounds<T> for RangeFrom<T>
impl<T> RangeBounds<T> for RangeFrom<T>
1.15.0 (const: unstable) · sourceimpl<T> SliceIndex<[T]> for RangeFrom<usize>
impl<T> SliceIndex<[T]> for RangeFrom<usize>
const: unstable · sourcefn get(self, slice: &[T]) -> Option<&[T]>
fn get(self, slice: &[T]) -> Option<&[T]>
slice_index_methods
)const: unstable · sourcefn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>
fn get_mut(self, slice: &mut [T]) -> Option<&mut [T]>
slice_index_methods
)const: unstable · sourceunsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]
unsafe fn get_unchecked(self, slice: *const [T]) -> *const [T]
slice_index_methods
)slice
pointer
is undefined behavior even if the resulting reference is not used. Read moreconst: unstable · sourceunsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]
unsafe fn get_unchecked_mut(self, slice: *mut [T]) -> *mut [T]
slice_index_methods
)slice
pointer
is undefined behavior even if the resulting reference is not used. Read more1.20.0 (const: unstable) · sourceimpl SliceIndex<str> for RangeFrom<usize>
impl SliceIndex<str> for RangeFrom<usize>
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
.
const: unstable · sourcefn get(
self,
slice: &str
) -> Option<&<RangeFrom<usize> as SliceIndex<str>>::Output>
fn get(
self,
slice: &str
) -> Option<&<RangeFrom<usize> as SliceIndex<str>>::Output>
slice_index_methods
)const: unstable · sourcefn get_mut(
self,
slice: &mut str
) -> Option<&mut <RangeFrom<usize> as SliceIndex<str>>::Output>
fn get_mut(
self,
slice: &mut str
) -> Option<&mut <RangeFrom<usize> as SliceIndex<str>>::Output>
slice_index_methods
)const: unstable · sourceunsafe fn get_unchecked(
self,
slice: *const str
) -> *const <RangeFrom<usize> as SliceIndex<str>>::Output
unsafe fn get_unchecked(
self,
slice: *const str
) -> *const <RangeFrom<usize> as SliceIndex<str>>::Output
slice_index_methods
)slice
pointer
is undefined behavior even if the resulting reference is not used. Read moreconst: unstable · sourceunsafe fn get_unchecked_mut(
self,
slice: *mut str
) -> *mut <RangeFrom<usize> as SliceIndex<str>>::Output
unsafe fn get_unchecked_mut(
self,
slice: *mut str
) -> *mut <RangeFrom<usize> as SliceIndex<str>>::Output
slice_index_methods
)slice
pointer
is undefined behavior even if the resulting reference is not used. Read moreconst: unstable · sourcefn index(self, slice: &str) -> &<RangeFrom<usize> as SliceIndex<str>>::OutputⓘNotable traits for RangeFrom<A>impl<A> Iterator for RangeFrom<A>where
A: Step, type Item = A;
fn index(self, slice: &str) -> &<RangeFrom<usize> as SliceIndex<str>>::OutputⓘNotable traits for RangeFrom<A>impl<A> Iterator for RangeFrom<A>where
A: Step, type Item = A;
A: Step, type Item = A;
slice_index_methods
)const: unstable · sourcefn index_mut(
self,
slice: &mut str
) -> &mut <RangeFrom<usize> as SliceIndex<str>>::OutputⓘNotable traits for RangeFrom<A>impl<A> Iterator for RangeFrom<A>where
A: Step, type Item = A;
fn index_mut(
self,
slice: &mut str
) -> &mut <RangeFrom<usize> as SliceIndex<str>>::OutputⓘNotable traits for RangeFrom<A>impl<A> Iterator for RangeFrom<A>where
A: Step, type Item = A;
A: Step, type Item = A;
slice_index_methods
)