Struct core::iter::Peekable 1.0.0[−][src]
An iterator with a peek()
that returns an optional reference to the next
element.
This struct
is created by the peekable
method on Iterator
. See its
documentation for more.
Implementations
impl<I: Iterator> Peekable<I>
[src]
pub fn peek(&mut self) -> Option<&I::Item>
[src]
Returns a reference to the next() value without advancing the iterator.
Like next
, if there is a value, it is wrapped in a Some(T)
.
But if the iteration is over, None
is returned.
Because peek()
returns a reference, and many iterators iterate over
references, there can be a possibly confusing situation where the
return value is a double reference. You can see this effect in the
examples below.
Examples
Basic usage:
let xs = [1, 2, 3]; let mut iter = xs.iter().peekable(); // peek() lets us see into the future assert_eq!(iter.peek(), Some(&&1)); assert_eq!(iter.next(), Some(&1)); assert_eq!(iter.next(), Some(&2)); // The iterator does not advance even if we `peek` multiple times assert_eq!(iter.peek(), Some(&&3)); assert_eq!(iter.peek(), Some(&&3)); assert_eq!(iter.next(), Some(&3)); // After the iterator is finished, so is `peek()` assert_eq!(iter.peek(), None); assert_eq!(iter.next(), None);Run
pub fn peek_mut(&mut self) -> Option<&mut I::Item>
[src]
Returns a mutable reference to the next() value without advancing the iterator.
Like next
, if there is a value, it is wrapped in a Some(T)
.
But if the iteration is over, None
is returned.
Because peek_mut()
returns a reference, and many iterators iterate over
references, there can be a possibly confusing situation where the
return value is a double reference. You can see this effect in the examples
below.
Examples
Basic usage:
#![feature(peekable_peek_mut)] let mut iter = [1, 2, 3].iter().peekable(); // Like with `peek()`, we can see into the future without advancing the iterator. assert_eq!(iter.peek_mut(), Some(&mut &1)); assert_eq!(iter.peek_mut(), Some(&mut &1)); assert_eq!(iter.next(), Some(&1)); // Peek into the iterator and set the value behind the mutable reference. if let Some(p) = iter.peek_mut() { assert_eq!(*p, &2); *p = &5; } // The value we put in reappears as the iterator continues. assert_eq!(iter.collect::<Vec<_>>(), vec![&5, &3]);Run
pub fn next_if(
&mut self,
func: impl FnOnce(&I::Item) -> bool
) -> Option<I::Item>
1.51.0[src]
&mut self,
func: impl FnOnce(&I::Item) -> bool
) -> Option<I::Item>
Consume and return the next value of this iterator if a condition is true.
If func
returns true
for the next value of this iterator, consume and return it.
Otherwise, return None
.
Examples
Consume a number if it's equal to 0.
let mut iter = (0..5).peekable(); // The first item of the iterator is 0; consume it. assert_eq!(iter.next_if(|&x| x == 0), Some(0)); // The next item returned is now 1, so `consume` will return `false`. assert_eq!(iter.next_if(|&x| x == 0), None); // `next_if` saves the value of the next item if it was not equal to `expected`. assert_eq!(iter.next(), Some(1));Run
Consume any number less than 10.
let mut iter = (1..20).peekable(); // Consume all numbers less than 10 while iter.next_if(|&x| x < 10).is_some() {} // The next value returned will be 10 assert_eq!(iter.next(), Some(10));Run
pub fn next_if_eq<T>(&mut self, expected: &T) -> Option<I::Item> where
T: ?Sized,
I::Item: PartialEq<T>,
1.51.0[src]
T: ?Sized,
I::Item: PartialEq<T>,
Consume and return the next item if it is equal to expected
.
Example
Consume a number if it's equal to 0.
let mut iter = (0..5).peekable(); // The first item of the iterator is 0; consume it. assert_eq!(iter.next_if_eq(&0), Some(0)); // The next item returned is now 1, so `consume` will return `false`. assert_eq!(iter.next_if_eq(&0), None); // `next_if_eq` saves the value of the next item if it was not equal to `expected`. assert_eq!(iter.next(), Some(1));Run
Trait Implementations
impl<I: Clone + Iterator> Clone for Peekable<I> where
I::Item: Clone,
[src]
I::Item: Clone,
fn clone(&self) -> Peekable<I>ⓘ
[src]
fn clone_from(&mut self, source: &Self)
[src]
impl<I: Debug + Iterator> Debug for Peekable<I> where
I::Item: Debug,
[src]
I::Item: Debug,
impl<I> DoubleEndedIterator for Peekable<I> where
I: DoubleEndedIterator,
1.38.0[src]
I: DoubleEndedIterator,
fn next_back(&mut self) -> Option<Self::Item>
[src]
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
[src]
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn rfold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, Self::Item) -> Acc,
[src]
Fold: FnMut(Acc, Self::Item) -> Acc,
fn advance_back_by(&mut self, n: usize) -> Result<(), usize>
[src]
fn nth_back(&mut self, n: usize) -> Option<Self::Item>
1.37.0[src]
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
1.27.0[src]
Self: Sized,
P: FnMut(&Self::Item) -> bool,
impl<I: ExactSizeIterator> ExactSizeIterator for Peekable<I>
[src]
impl<I: FusedIterator> FusedIterator for Peekable<I>
1.26.0[src]
impl<I: InPlaceIterable> InPlaceIterable for Peekable<I>
[src]
impl<I: Iterator> Iterator for Peekable<I>
[src]
type Item = I::Item
The type of the elements being iterated over.
fn next(&mut self) -> Option<I::Item>
[src]
fn count(self) -> usize
[src]
fn nth(&mut self, n: usize) -> Option<I::Item>
[src]
fn last(self) -> Option<I::Item>
[src]
fn size_hint(&self) -> (usize, Option<usize>)
[src]
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>,
[src]
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
fn fold<Acc, Fold>(self, init: Acc, fold: Fold) -> Acc where
Fold: FnMut(Acc, Self::Item) -> Acc,
[src]
Fold: FnMut(Acc, Self::Item) -> Acc,
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_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 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<S: Iterator, I: Iterator> SourceIter for Peekable<I> where
I: SourceIter<Source = S>,
[src]
I: SourceIter<Source = S>,
type Source = S
inplace_iteration
)A source stage in an iterator pipeline.
unsafe fn as_inner(&mut self) -> &mut S
[src]
impl<I> TrustedLen for Peekable<I> where
I: TrustedLen,
[src]
I: TrustedLen,
Auto Trait Implementations
impl<I> Send for Peekable<I> where
I: Send,
<I as Iterator>::Item: Send,
[src]
I: Send,
<I as Iterator>::Item: Send,
impl<I> Sync for Peekable<I> where
I: Sync,
<I as Iterator>::Item: Sync,
[src]
I: Sync,
<I as Iterator>::Item: Sync,
impl<I> Unpin for Peekable<I> where
I: Unpin,
<I as Iterator>::Item: Unpin,
[src]
I: Unpin,
<I as Iterator>::Item: 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>,