[−][src]Struct peekmore::PeekMoreIterator
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
impl<I: Iterator> PeekMoreIterator<I>
[src]
pub fn peek(&mut self) -> Option<&I::Item>
[src]
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);
pub fn peek_next(&mut self) -> Option<&I::Item>
[src]
Advance the cursor to the next element and return a reference to that value.
pub fn peek_previous(&mut self) -> Result<Option<&I::Item>, PeekMoreError>
[src]
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.
pub fn peek_forward(&mut self, n: usize) -> Option<&I::Item>
[src]
Move the cursor n
steps forward and peek at the element the cursor then points to.
pub fn peek_backward(
&mut self,
n: usize
) -> Result<Option<&I::Item>, PeekMoreError>
[src]
&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.
pub fn peek_backward_or_first(&mut self, n: usize) -> Option<&I::Item>
[src]
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.
pub fn peek_nth(&mut self, n: usize) -> Option<&I::Item>
[src]
Peek at the nth element without moving the cursor.
pub fn advance_cursor(&mut self) -> &mut PeekMoreIterator<I>ⓘNotable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
[src]
Notable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
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.
pub fn advance_cursor_by(&mut self, n: usize) -> &mut PeekMoreIterator<I>ⓘNotable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
[src]
Notable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
Advance the cursor n
elements forward.
This does not advance the iterator itself. To advance the iterator, call next()
instead.
pub fn advance_cursor_while<P: Fn(Option<&I::Item>) -> bool>(
&mut self,
predicate: P
) -> &mut PeekMoreIterator<I>ⓘNotable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
[src]
&mut self,
predicate: P
) -> &mut PeekMoreIterator<I>ⓘ
Notable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
Moves the cursor forward until the predicate is no longer true
.
pub fn move_cursor_back(
&mut self
) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
[src]
&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.
pub fn move_cursor_back_by(
&mut self,
n: usize
) -> Result<&mut PeekMoreIterator<I>, PeekMoreError>
[src]
&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.
pub fn move_cursor_back_or_reset(
&mut self,
n: usize
) -> &mut PeekMoreIterator<I>ⓘNotable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
[src]
&mut self,
n: usize
) -> &mut PeekMoreIterator<I>ⓘ
Notable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
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.
pub fn move_nth(&mut self, n: usize) -> &mut PeekMoreIterator<I>ⓘNotable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
[src]
Notable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
Move the cursor to the n-th element of the queue.
pub fn reset_view(&mut self)
[src]
Deprecated: use reset_cursor
instead.
pub fn reset_cursor(&mut self)
[src]
Reset the position of the cursor.
If peek
is called just after a reset, it will return a reference to the first element.
pub fn truncate_iterator_to_cursor(&mut self)
[src]
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));
pub fn peek_range(&mut self, start: usize, end: usize) -> &[Option<I::Item>]
[src]
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!"), }
pub fn peek_amount(&mut self, n: usize) -> &[Option<I::Item>]
[src]
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"), }
Trait Implementations
impl<I: Clone + Iterator> Clone for PeekMoreIterator<I> where
I::Item: Clone,
[src]
I::Item: Clone,
pub fn clone(&self) -> PeekMoreIterator<I>ⓘNotable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
[src]
Notable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
pub fn clone_from(&mut self, source: &Self)
1.0.0[src]
impl<I: Debug + Iterator> Debug for PeekMoreIterator<I> where
I::Item: Debug,
[src]
I::Item: Debug,
impl<I: ExactSizeIterator> ExactSizeIterator for PeekMoreIterator<I>
[src]
Uses ExactSizeIterator
default implementation.
impl<I: FusedIterator> FusedIterator for PeekMoreIterator<I>
[src]
Uses FusedIterator
default implementation.
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I>
[src]
type Item = I::Item
The type of the elements being iterated over.
pub fn next(&mut self) -> Option<Self::Item>
[src]
pub fn size_hint(&self) -> (usize, Option<usize>)
1.0.0[src]
pub fn count(self) -> usize
1.0.0[src]
pub fn last(self) -> Option<Self::Item>
1.0.0[src]
pub fn advance_by(&mut self, n: usize) -> Result<(), usize>
[src]
pub fn nth(&mut self, n: usize) -> Option<Self::Item>
1.0.0[src]
pub fn step_by(self, step: usize) -> StepBy<Self>
1.28.0[src]
pub fn chain<U>(self, other: U) -> Chain<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator<Item = Self::Item>,
1.0.0[src]
U: IntoIterator<Item = Self::Item>,
pub fn zip<U>(self, other: U) -> Zip<Self, <U as IntoIterator>::IntoIter> where
U: IntoIterator,
1.0.0[src]
U: IntoIterator,
pub fn map<B, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> B,
1.0.0[src]
F: FnMut(Self::Item) -> B,
pub fn for_each<F>(self, f: F) where
F: FnMut(Self::Item),
1.21.0[src]
F: FnMut(Self::Item),
pub fn filter<P>(self, predicate: P) -> Filter<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn filter_map<B, F>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(Self::Item) -> Option<B>,
pub fn enumerate(self) -> Enumerate<Self>
1.0.0[src]
pub fn peekable(self) -> Peekable<Self>
1.0.0[src]
pub fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn map_while<B, P>(self, predicate: P) -> MapWhile<Self, P> where
P: FnMut(Self::Item) -> Option<B>,
[src]
P: FnMut(Self::Item) -> Option<B>,
pub fn skip(self, n: usize) -> Skip<Self>
1.0.0[src]
pub fn take(self, n: usize) -> Take<Self>
1.0.0[src]
pub fn scan<St, B, F>(self, initial_state: St, f: F) -> Scan<Self, St, F> where
F: FnMut(&mut St, Self::Item) -> Option<B>,
1.0.0[src]
F: FnMut(&mut St, Self::Item) -> Option<B>,
pub fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: IntoIterator,
1.0.0[src]
F: FnMut(Self::Item) -> U,
U: IntoIterator,
pub fn flatten(self) -> Flatten<Self> where
Self::Item: IntoIterator,
1.29.0[src]
Self::Item: IntoIterator,
pub fn fuse(self) -> Fuse<Self>
1.0.0[src]
pub fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
1.0.0[src]
F: FnMut(&Self::Item),
pub fn by_ref(&mut self) -> &mut Self
1.0.0[src]
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]pub fn collect<B>(self) -> B where
B: FromIterator<Self::Item>,
1.0.0[src]
B: FromIterator<Self::Item>,
pub fn partition<B, F>(self, f: F) -> (B, B) where
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
1.0.0[src]
F: FnMut(&Self::Item) -> bool,
B: Default + Extend<Self::Item>,
pub fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
Self: DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
T: 'a,
[src]
Self: DoubleEndedIterator<Item = &'a mut T>,
P: FnMut(&T) -> bool,
T: 'a,
pub fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool,
[src]
P: FnMut(Self::Item) -> bool,
pub fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
1.27.0[src]
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
pub fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
1.27.0[src]
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>,
pub fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B,
1.0.0[src]
F: FnMut(B, Self::Item) -> B,
pub fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item,
[src]
F: FnMut(Self::Item, Self::Item) -> Self::Item,
pub fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
pub fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool,
1.0.0[src]
F: FnMut(Self::Item) -> bool,
pub fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool,
1.0.0[src]
P: FnMut(&Self::Item) -> bool,
pub fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>,
1.30.0[src]
F: FnMut(Self::Item) -> Option<B>,
pub 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]
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>,
pub fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
1.0.0[src]
P: FnMut(Self::Item) -> bool,
pub fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
1.0.0[src]
Self: ExactSizeIterator + DoubleEndedIterator,
P: FnMut(Self::Item) -> bool,
pub fn max(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
pub fn min(self) -> Option<Self::Item> where
Self::Item: Ord,
1.0.0[src]
Self::Item: Ord,
pub fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
F: FnMut(&Self::Item) -> B,
B: Ord,
pub fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
F: FnMut(&Self::Item) -> B,
B: Ord,
1.6.0[src]
F: FnMut(&Self::Item) -> B,
B: Ord,
pub fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
1.15.0[src]
F: FnMut(&Self::Item, &Self::Item) -> Ordering,
pub fn rev(self) -> Rev<Self> where
Self: DoubleEndedIterator,
1.0.0[src]
Self: DoubleEndedIterator,
pub fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
1.0.0[src]
Self: Iterator<Item = (A, B)>,
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
pub fn copied<'a, T>(self) -> Copied<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
1.36.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Copy,
pub fn cloned<'a, T>(self) -> Cloned<Self> where
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
1.0.0[src]
Self: Iterator<Item = &'a T>,
T: 'a + Clone,
pub fn cycle(self) -> Cycle<Self> where
Self: Clone,
1.0.0[src]
Self: Clone,
pub fn sum<S>(self) -> S where
S: Sum<Self::Item>,
1.11.0[src]
S: Sum<Self::Item>,
pub fn product<P>(self) -> P where
P: Product<Self::Item>,
1.11.0[src]
P: Product<Self::Item>,
pub fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
1.5.0[src]
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord,
pub fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
pub fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub 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>,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
pub fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
pub fn eq_by<I, F>(self, other: I, eq: F) -> bool where
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
[src]
I: IntoIterator,
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
pub fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>,
pub fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
1.5.0[src]
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>,
pub fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>,
[src]
Self::Item: PartialOrd<Self::Item>,
pub fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
[src]
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>,
pub fn is_sorted_by_key<F, K>(self, f: F) -> bool where
K: PartialOrd<K>,
F: FnMut(Self::Item) -> K,
[src]
K: PartialOrd<K>,
F: FnMut(Self::Item) -> K,
Auto Trait Implementations
impl<I> Send for PeekMoreIterator<I> where
I: Send,
<I as Iterator>::Item: Send,
[src]
I: Send,
<I as Iterator>::Item: Send,
impl<I> Sync for PeekMoreIterator<I> where
I: Sync,
<I as Iterator>::Item: Sync,
[src]
I: Sync,
<I as Iterator>::Item: Sync,
impl<I> Unpin for PeekMoreIterator<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<I> IntoIterator for I where
I: Iterator,
[src]
I: Iterator,
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?
pub fn into_iter(self) -> I
[src]
impl<I> PeekMore for I where
I: Iterator,
[src]
I: Iterator,
pub fn peekmore(Self) -> PeekMoreIterator<I>ⓘNotable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
[src]
Notable traits for PeekMoreIterator<I>
impl<'a, I: Iterator> Iterator for PeekMoreIterator<I> type Item = I::Item;
impl<T> ToOwned for T where
T: Clone,
[src]
T: Clone,
type Owned = T
The resulting type after obtaining ownership.
pub fn to_owned(&self) -> T
[src]
pub fn clone_into(&self, target: &mut T)
[src]
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(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,