Struct peekmore::PeekMoreIterator
source · pub struct PeekMoreIterator<I: Iterator> { /* private fields */ }
Expand description
This iterator makes it possible to peek multiple times without consuming a value. In reality the underlying iterator will be consumed, but the values will be stored in a queue. This queue allows us to peek at unconsumed elements (as far as the multi-peek iterator is concerned). When the iterator consumes an element, the element at the front of the queue will be dequeued, and will no longer be peekable.
Implementations§
source§impl<I: Iterator> PeekMoreIterator<I>
impl<I: Iterator> PeekMoreIterator<I>
sourcepub fn peek(&mut self) -> Option<&I::Item>
pub fn peek(&mut self) -> Option<&I::Item>
Get a reference to the element where the cursor currently points to. If no such element exists,
return None
will be returned.
If we haven’t advanced our cursor, it will point to the same element as Iterator::next()
would
return.
Note that the cursor can’t point to an element before the first unconsumed element within
the iterator. In a sense the cursor moves independently within the iterator.
But it can only point to unconsumed elements.
The following illustration aims to show how peek()
behaves. i
represents the position
of the iterator (i.e. the next value that will be returned if next()
is called) and j
represents the position of the cursor (i.e. the current element referenced if
peek()
is called).
In example code next to the illustrations, the first element 1
is analogous to A
,
2
to B
, etc.
The example below primarily uses advance_cursor()
to move the cursor and peek()
to
peek at the element the cursor points to, but many often more convenient methods exist to
change the element cursor points at, or to peek at those elements.
- Let’s start:
use peekmore::PeekMore;
// Initialize our iterator.
let iterable = [1, 2, 3, 4];
let mut iterator = iterable.iter().peekmore();
----- ----- ----- -----
| A | --> | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^
i, j
- Call
peek()
:
let j = iterator.peek();
assert_eq!(j, Some(&&1));
----- ----- ----- -----
| A | --> | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^
i, j
returns Some(&A)
- Call
advance_cursor()
let iter = iterator.advance_cursor();
----- ----- ----- -----
| A | --> | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^ ^
i j
- Call
peek()
The reference returned by peek()
will not change, similar to the behaviour of
core::iter::Peekable::peek
. In order to move to the next peekable element, we need to
advance the cursor.
let j = iterator.peek();
assert_eq!(j, Some(&&2));
// Calling `peek()` multiple times doesn't shift the position of the cursor;
// a reference to the same element will be returned each call.
assert_eq!(iterator.peek(), Some(&&2));
assert_eq!(iterator.peek(), Some(&&2));
----- ----- ----- -----
| A | --> | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^ ^
i j
returns Some(&B)
- Call
next()
By calling next, the underlying iterator will be advanced andthe element represented by A
will be consumed. It won’t be possible to peek at A
anymore.
let i = iterator.next();
assert_eq!(i, Some(&1));
----- ----- ----- -----
| A | | B | --> | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^
i, j
returns Some(A)
- Call
next()
.
The underlying iterator is advanced again.
As a result, the cursor position also shifts to the next iterator position, which happens if
the underlying iterator consumed an element where our cursor pointed at (that is if j < i
).
// Show that the cursor still points at the second element.
let j = iterator.peek();
assert_eq!(j, Some(&&2));
// Consume the second element.
let i = iterator.next();
assert_eq!(i, Some(&2));
// Our cursor previously pointed at the element represented by B. Since that element has
// been consumed, the cursor shifts to the next unconsumed element: C.
let j = iterator.peek();
assert_eq!(j, Some(&&3));
----- ----- ----- -----
| A | | B | | C | --> | D | --> None --> None --> ...
----- ----- ----- -----
^
i, j
returns Some(B)
- Consume more elements by calling
next()
until we reachNone
:
let i = iterator.next();
assert_eq!(i, Some(&3));
let j = iterator.peek();
assert_eq!(j, Some(&&4));
let i = iterator.next();
assert_eq!(i, Some(&4));
let j = iterator.peek();
assert_eq!(j, None);
let i = iterator.next();
assert_eq!(i, None);
sourcepub fn peek_first(&mut self) -> Option<&I::Item>
pub fn peek_first(&mut self) -> Option<&I::Item>
Peeks at the first unconsumed element, regardless of where the cursor currently is.
sourcepub fn peek_next(&mut self) -> Option<&I::Item>
pub fn peek_next(&mut self) -> Option<&I::Item>
Advance the cursor to the next element and return a reference to that value.
sourcepub fn peek_previous(&mut self) -> Result<Option<&I::Item>, PeekMoreError>
pub fn peek_previous(&mut self) -> Result<Option<&I::Item>, PeekMoreError>
Try to peek at a previous element. If no such element exists, an Err
result containing a
PeekMoreError::ElementHasBeenConsumed
will be returned.
If a previous element does exist, an option wrapped in an Ok
result will be returned.
sourcepub fn peek_forward(&mut self, n: usize) -> Option<&I::Item>
pub fn peek_forward(&mut self, n: usize) -> Option<&I::Item>
Move the cursor n
steps forward and peek at the element the cursor then points to.
sourcepub fn peek_backward(
&mut self,
n: usize
) -> Result<Option<&I::Item>, PeekMoreError>
pub fn peek_backward( &mut self, n: usize ) -> Result<Option<&I::Item>, PeekMoreError>
Move the cursor n
steps backward and peek at the element the cursor then points to.
If there aren’t n
elements prior to the element the cursor currently points at, a
PeekMoreError::ElementHasBeenConsumed
is returned instead.
The cursor will then stay at the position it was prior to calling this method.
If you want to peek at the first unconsumed element instead of returning with an error, you
can use the peek_backward_or_first
method instead.
sourcepub fn peek_backward_or_first(&mut self, n: usize) -> Option<&I::Item>
pub fn peek_backward_or_first(&mut self, n: usize) -> Option<&I::Item>
Move the cursor n
steps backward and peek at the element the cursor then points to, or
if there aren’t n
elements prior to the element the cursor currently points to, peek at
the first unconsumed element instead.
sourcepub fn peek_nth(&mut self, n: usize) -> Option<&I::Item>
pub fn peek_nth(&mut self, n: usize) -> Option<&I::Item>
Peek at the nth element without moving the cursor.
sourcepub fn advance_cursor(&mut self) -> &mut PeekMoreIterator<I> ⓘ
pub fn advance_cursor(&mut self) -> &mut PeekMoreIterator<I> ⓘ
Advance the cursor to the next peekable element.
This method does not advance the iterator itself. To advance the iterator, call next()
instead.
A mutable reference to the iterator is returned, which allows the operation to be chained.
sourcepub fn advance_cursor_by(&mut self, n: usize) -> &mut PeekMoreIterator<I> ⓘ
pub fn advance_cursor_by(&mut self, n: usize) -> &mut PeekMoreIterator<I> ⓘ
Advance the cursor n
elements forward.
This does not advance the iterator itself. To advance the iterator, call next()
instead.
sourcepub fn advance_cursor_while<P: Fn(Option<&I::Item>) -> bool>(
&mut self,
predicate: P
) -> &mut PeekMoreIterator<I> ⓘ
pub fn advance_cursor_while<P: Fn(Option<&I::Item>) -> bool>( &mut self, predicate: P ) -> &mut PeekMoreIterator<I> ⓘ
Moves the cursor forward until the predicate is no longer true
.
After this method returns, the cursor points to the first element that fails predicate
. If no peeked elements
pass predicate
then the cursor will remain unchanged.
This does not advance the iterator itself. To advance the iterator, call next()
instead.
sourcepub fn move_cursor_back(
&mut self
) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
pub fn move_cursor_back( &mut self ) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
Move the cursor to the previous peekable element.
If such an element doesn’t exist, a PeekMoreError::ElementHasBeenConsumed
will be
returned.
If we can move to a previous element, a mutable reference to the iterator,
wrapped in the Ok
variant of Result
will be returned.
sourcepub fn move_cursor_back_by(
&mut self,
n: usize
) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
pub fn move_cursor_back_by( &mut self, n: usize ) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
Move the cursor n
elements backward. If there aren’t n
unconsumed elements prior to the
cursor, an error will be returned instead. In case of an error, the cursor will stay at the position
it pointed at prior to calling this method.
If you want to reset the cursor to the first unconsumed element even if there aren’t n
unconsumed elements before the cursor position, the move_backward_or_reset
method can be
used.
sourcepub fn move_cursor_back_or_reset(
&mut self,
n: usize
) -> &mut PeekMoreIterator<I> ⓘ
pub fn move_cursor_back_or_reset( &mut self, n: usize ) -> &mut PeekMoreIterator<I> ⓘ
Move the cursor n
elements backward, or reset its position to the first non-consumed element.
The latter happens when the cursor position is smaller than the elements it has to move
backwards by.
sourcepub fn move_nth(&mut self, n: usize) -> &mut PeekMoreIterator<I> ⓘ
pub fn move_nth(&mut self, n: usize) -> &mut PeekMoreIterator<I> ⓘ
Move the cursor to the n-th element of the queue.
sourcepub fn reset_view(&mut self)
👎Deprecated
pub fn reset_view(&mut self)
Deprecated: use reset_cursor
instead.
sourcepub fn reset_cursor(&mut self)
pub fn reset_cursor(&mut self)
Reset the position of the cursor.
If peek
is called just after a reset, it will return a reference to the first element.
sourcepub fn cursor(&self) -> usize
pub fn cursor(&self) -> usize
Return the current cursor position. This is intended for use by code that more finely controls where the iterator resets to.
sourcepub fn truncate_iterator_to_cursor(&mut self)
pub fn truncate_iterator_to_cursor(&mut self)
Remove all elements from the start of the iterator until reaching the same
position as the cursor by calling Iterator::next()
.
After calling this method, iter.peek() == iter.next().as_ref()
.
use peekmore::PeekMore;
let iterable = [1, 2, 3, 4];
let mut iter = iterable.iter().peekmore();
iter.advance_cursor_by(2);
assert_eq!(iter.peek(), Some(&&3));
assert_eq!(iter.next(), Some(&1));
iter.truncate_iterator_to_cursor();
assert_eq!(iter.peek(), Some(&&3));
assert_eq!(iter.next(), Some(&3));
sourcepub fn peek_range(&mut self, start: usize, end: usize) -> &[Option<I::Item>]
pub fn peek_range(&mut self, start: usize, end: usize) -> &[Option<I::Item>]
Returns a view into the next start
(inclusive) to end
(exclusive) elements.
Note: start
and end
represent indices and start at 0
. These indices always start
at the beginning of the queue (the unconsumed iterator) and don’t take the position of the cursor
into account.
Panics
Panics if start > end
, in which case the range would be negative.
use peekmore::PeekMore;
let iterable = [1, 2, 3, 4];
let mut iter = iterable.iter().peekmore();
match iter.peek_range(1, 3) {
[Some(2), Some(p)] => println!("Yay! we found number {} after number 2", p),
_ => println!("Oh noes!"),
}
sourcepub fn peek_amount(&mut self, n: usize) -> &[Option<I::Item>]
pub fn peek_amount(&mut self, n: usize) -> &[Option<I::Item>]
Returns a view into the next n
unconsumed elements of the iterator.
Here, n
represents the amount of elements as counted from the start of the unconsumed iterator.
For example, if we created a (peekmore) iterator from the array [1, 2, 3]
and consume the first
element by calling the regular Iterator::next
method, and then call peek_amount(3)
, the iterator will
return &[Some(2), Some(3), None]
. Here Some(2)
and Some(3)
are queued elements which
we can peek at, and are not consumed by the iterator yet. None
is the last element returned by
our view, since our original iterator is sized and doesn’t contain more elements. Thus in the absence
of additional elements, we return None
. This method is a variation on peek_range
.
You could instead have called peek_range(0, n)
(note that peek_range
takes indices as arguments
instead of an amount).
Note: This method does not use or modify the position of the cursor.
Example:
use peekmore::PeekMore;
let iterable = [1, 2, 3];
let mut iter = iterable.iter().peekmore();
match iter.peek_amount(4) { // -> &[Option(&1), Option(&2), Option(&3), None]
[Some(a), Some(b), Some(c), None] => println!("Found a match ({}, {}, {}) ", a, b, c),
_ => eprintln!("Expected (just) 3 more values"),
}
sourcepub fn next_if(
&mut self,
func: impl FnOnce(&I::Item) -> bool
) -> Option<I::Item>
pub fn next_if( &mut self, func: impl FnOnce(&I::Item) -> bool ) -> Option<I::Item>
Consumes and returns the next item of this iterator if a condition is true.
If func
returns true
for the next item of this iterator, consume and return it.
Otherwise, return None
.
Note: This function always uses the next item of the iterator and it is independent of the cursor location.
Example:
Consume items one-by-one.
use peekmore::PeekMore;
let mut iter = (1..5).peekmore();
assert_eq!(iter.next_if(|&x| x == 1), Some(1));
// next_eq does not care about the cursor position
let mut iter = iter.advance_cursor();
assert_eq!(iter.peek(), Some(&3));
assert_eq!(iter.next_if(|&x| x == 2), Some(2));
Consume a range of items.
use peekmore::PeekMore;
let mut iter = (1..15).peekmore();
while iter.next_if(|&x| x <= 10).is_some() {}
assert_eq!(iter.next(), Some(11));
Trait Implementations§
source§impl<I: ExactSizeIterator> ExactSizeIterator for PeekMoreIterator<I>
impl<I: ExactSizeIterator> ExactSizeIterator for PeekMoreIterator<I>
Uses ExactSizeIterator
default implementation.
source§impl<I: Iterator> Iterator for PeekMoreIterator<I>
impl<I: Iterator> Iterator for PeekMoreIterator<I>
source§fn next(&mut self) -> Option<Self::Item>
fn next(&mut self) -> Option<Self::Item>
source§fn next_chunk<const N: usize>(
&mut self
) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where
Self: Sized,
fn next_chunk<const N: usize>( &mut self ) -> Result<[Self::Item; N], IntoIter<Self::Item, N>>where Self: Sized,
iter_next_chunk
)N
values. Read more1.0.0 · source§fn size_hint(&self) -> (usize, Option<usize>)
fn size_hint(&self) -> (usize, Option<usize>)
1.0.0 · source§fn count(self) -> usizewhere
Self: Sized,
fn count(self) -> usizewhere Self: Sized,
1.0.0 · source§fn last(self) -> Option<Self::Item>where
Self: Sized,
fn last(self) -> Option<Self::Item>where Self: Sized,
source§fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
fn advance_by(&mut self, n: usize) -> Result<(), NonZeroUsize>
iter_advance_by
)n
elements. Read more1.0.0 · source§fn nth(&mut self, n: usize) -> Option<Self::Item>
fn nth(&mut self, n: usize) -> Option<Self::Item>
n
th element of the iterator. Read more1.28.0 · source§fn step_by(self, step: usize) -> StepBy<Self>where
Self: Sized,
fn step_by(self, step: usize) -> StepBy<Self>where Self: Sized,
1.0.0 · source§fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter>where Self: Sized, U: IntoIterator<Item = Self::Item>,
1.0.0 · source§fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where
Self: Sized,
U: IntoIterator,
fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter>where Self: Sized, U: IntoIterator,
source§fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where
Self: Sized,
G: FnMut() -> Self::Item,
fn intersperse_with<G>(self, separator: G) -> IntersperseWith<Self, G>where Self: Sized, G: FnMut() -> Self::Item,
iter_intersperse
)separator
between adjacent items of the original iterator. Read more1.0.0 · source§fn map<B, F>(self, f: F) -> Map<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> B,
fn map<B, F>(self, f: F) -> Map<Self, F>where Self: Sized, F: FnMut(Self::Item) -> B,
1.21.0 · source§fn for_each<F>(self, f: F)where
Self: Sized,
F: FnMut(Self::Item),
fn for_each<F>(self, f: F)where Self: Sized, F: FnMut(Self::Item),
1.0.0 · source§fn filter<P>(self, predicate: P) -> Filter<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn filter<P>(self, predicate: P) -> Filter<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn enumerate(self) -> Enumerate<Self>where
Self: Sized,
fn enumerate(self) -> Enumerate<Self>where Self: Sized,
1.0.0 · source§fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.0.0 · source§fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>where
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,
1.57.0 · source§fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where
Self: Sized,
P: FnMut(Self::Item) -> Option<B>,
fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P>where Self: Sized, P: FnMut(Self::Item) -> Option<B>,
1.0.0 · source§fn skip(self, n: usize) -> Skip<Self>where
Self: Sized,
fn skip(self, n: usize) -> Skip<Self>where Self: Sized,
n
elements. Read more1.0.0 · source§fn take(self, n: usize) -> Take<Self>where
Self: Sized,
fn take(self, n: usize) -> Take<Self>where Self: Sized,
n
elements, or fewer
if the underlying iterator ends sooner. Read more1.0.0 · source§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>,
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>,
1.0.0 · source§fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where
Self: Sized,
U: IntoIterator,
F: FnMut(Self::Item) -> U,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F>where Self: Sized, U: IntoIterator, F: FnMut(Self::Item) -> U,
1.0.0 · source§fn inspect<F>(self, f: F) -> Inspect<Self, F>where
Self: Sized,
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F>where Self: Sized, F: FnMut(&Self::Item),
1.0.0 · source§fn by_ref(&mut self) -> &mut Selfwhere
Self: Sized,
fn by_ref(&mut self) -> &mut Selfwhere Self: Sized,
1.0.0 · source§fn collect<B>(self) -> Bwhere
B: FromIterator<Self::Item>,
Self: Sized,
fn collect<B>(self) -> Bwhere B: FromIterator<Self::Item>, Self: Sized,
source§fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere
E: Extend<Self::Item>,
Self: Sized,
fn collect_into<E>(self, collection: &mut E) -> &mut Ewhere E: Extend<Self::Item>, Self: Sized,
iter_collect_into
)1.0.0 · source§fn partition<B, F>(self, f: F) -> (B, B)where
Self: Sized,
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool,
fn partition<B, F>(self, f: F) -> (B, B)where Self: Sized, B: Default + Extend<Self::Item>, F: FnMut(&Self::Item) -> bool,
source§fn is_partitioned<P>(self, predicate: P) -> boolwhere
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn is_partitioned<P>(self, predicate: P) -> boolwhere Self: Sized, P: FnMut(Self::Item) -> bool,
iter_is_partitioned
)true
precede all those that return false
. Read more1.27.0 · source§fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Output = B>,
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> Rwhere Self: Sized, F: FnMut(B, Self::Item) -> R, R: Try<Output = B>,
1.27.0 · source§fn try_for_each<F, R>(&mut self, f: F) -> Rwhere
Self: Sized,
F: FnMut(Self::Item) -> R,
R: Try<Output = ()>,
fn try_for_each<F, R>(&mut self, f: F) -> Rwhere Self: Sized, F: FnMut(Self::Item) -> R, R: Try<Output = ()>,
1.0.0 · source§fn fold<B, F>(self, init: B, f: F) -> Bwhere
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn fold<B, F>(self, init: B, f: F) -> Bwhere Self: Sized, F: FnMut(B, Self::Item) -> B,
1.51.0 · source§fn reduce<F>(self, f: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(Self::Item, Self::Item) -> Self::Item,
fn reduce<F>(self, f: F) -> Option<Self::Item>where Self: Sized, F: FnMut(Self::Item, Self::Item) -> Self::Item,
source§fn try_reduce<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<<R as Try>::Output>>>::TryTypewhere
Self: Sized,
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 Self: Sized, F: FnMut(Self::Item, Self::Item) -> R, R: Try<Output = Self::Item>, <R as Try>::Residual: Residual<Option<Self::Item>>,
iterator_try_reduce
)1.0.0 · source§fn all<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn all<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn any<F>(&mut self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> bool,
1.0.0 · source§fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where
Self: Sized,
P: FnMut(&Self::Item) -> bool,
fn find<P>(&mut self, predicate: P) -> Option<Self::Item>where Self: Sized, P: FnMut(&Self::Item) -> bool,
1.30.0 · source§fn find_map<B, F>(&mut self, f: F) -> Option<B>where
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn find_map<B, F>(&mut self, f: F) -> Option<B>where Self: Sized, F: FnMut(Self::Item) -> Option<B>,
source§fn try_find<F, R>(
&mut self,
f: F
) -> <<R as Try>::Residual as Residual<Option<Self::Item>>>::TryTypewhere
Self: Sized,
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 Self: Sized, F: FnMut(&Self::Item) -> R, R: Try<Output = bool>, <R as Try>::Residual: Residual<Option<Self::Item>>,
try_find
)1.0.0 · source§fn position<P>(&mut self, predicate: P) -> Option<usize>where
Self: Sized,
P: FnMut(Self::Item) -> bool,
fn position<P>(&mut self, predicate: P) -> Option<usize>where Self: Sized, P: FnMut(Self::Item) -> bool,
1.6.0 · source§fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item>where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn max_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn max_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.6.0 · source§fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where
B: Ord,
Self: Sized,
F: FnMut(&Self::Item) -> B,
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item>where B: Ord, Self: Sized, F: FnMut(&Self::Item) -> B,
1.15.0 · source§fn min_by<F>(self, compare: F) -> Option<Self::Item>where
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
fn min_by<F>(self, compare: F) -> Option<Self::Item>where Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.0.0 · source§fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Sized + Iterator<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB)where FromA: Default + Extend<A>, FromB: Default + Extend<B>, Self: Sized + Iterator<Item = (A, B)>,
1.36.0 · source§fn copied<'a, T>(self) -> Copied<Self>where
T: 'a + Copy,
Self: Sized + Iterator<Item = &'a T>,
fn copied<'a, T>(self) -> Copied<Self>where T: 'a + Copy, Self: Sized + Iterator<Item = &'a T>,
1.0.0 · source§fn cloned<'a, T>(self) -> Cloned<Self>where
T: 'a + Clone,
Self: Sized + Iterator<Item = &'a T>,
fn cloned<'a, T>(self) -> Cloned<Self>where T: 'a + Clone, Self: Sized + Iterator<Item = &'a T>,
source§fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where
Self: Sized,
fn array_chunks<const N: usize>(self) -> ArrayChunks<Self, N>where Self: Sized,
iter_array_chunks
)N
elements of the iterator at a time. Read more1.11.0 · source§fn sum<S>(self) -> Swhere
Self: Sized,
S: Sum<Self::Item>,
fn sum<S>(self) -> Swhere Self: Sized, S: Sum<Self::Item>,
1.11.0 · source§fn product<P>(self) -> Pwhere
Self: Sized,
P: Product<Self::Item>,
fn product<P>(self) -> Pwhere Self: Sized, P: Product<Self::Item>,
source§fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
fn cmp_by<I, F>(self, other: I, cmp: F) -> Orderingwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn partial_cmp<I>(self, other: I) -> Option<Ordering>where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn partial_cmp<I>(self, other: I) -> Option<Ordering>where I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
PartialOrd
elements of
this Iterator
with those of another. The comparison works like short-circuit
evaluation, returning a result without comparing the remaining elements.
As soon as an order can be determined, the evaluation stops and a result is returned. Read moresource§fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering>where
Self: Sized,
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 Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
iter_order_by
)Iterator
with those
of another with respect to the specified comparison function. Read more1.5.0 · source§fn eq<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn eq<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,
source§fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere
Self: Sized,
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
fn eq_by<I, F>(self, other: I, eq: F) -> boolwhere Self: Sized, I: IntoIterator, F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
iter_order_by
)1.5.0 · source§fn ne<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
Self: Sized,
fn ne<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialEq<<I as IntoIterator>::Item>, Self: Sized,
1.5.0 · source§fn lt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn lt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
less than those of another. Read more1.5.0 · source§fn le<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn le<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
less or equal to those of another. Read more1.5.0 · source§fn gt<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn gt<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
greater than those of another. Read more1.5.0 · source§fn ge<I>(self, other: I) -> boolwhere
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
Self: Sized,
fn ge<I>(self, other: I) -> boolwhere I: IntoIterator, Self::Item: PartialOrd<<I as IntoIterator>::Item>, Self: Sized,
Iterator
are lexicographically
greater than or equal to those of another. Read moresource§fn is_sorted_by<F>(self, compare: F) -> boolwhere
Self: Sized,
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
fn is_sorted_by<F>(self, compare: F) -> boolwhere Self: Sized, F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
is_sorted
)source§fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere
Self: Sized,
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>,
fn is_sorted_by_key<F, K>(self, f: F) -> boolwhere Self: Sized, F: FnMut(Self::Item) -> K, K: PartialOrd<K>,
is_sorted
)impl<I: FusedIterator> FusedIterator for PeekMoreIterator<I>
Uses FusedIterator
default implementation.