pub struct IterMut<'a, T> where T: 'a, { /* fields omitted */ }
A mutable iterator over the elements of a LinkedList.
This struct is created by LinkedList::iter_mut(). See its documentation for more.
impl<'_, T> IterMut<'_, T>[src]
pub fn insert_next(&mut self, element: T)[src]
Inserts the given element just after the element most recently returned by .next(). The inserted element does not appear in the iteration.
This method will be removed soon.
pub fn peek_next(&mut self) -> Option<&mut T>[src]
Provides a reference to the next element, without changing the iterator.
This method will be removed soon.
impl<'_, T> Debug for IterMut<'_, T> where
T: Debug, [src]1.17.0
impl<'a, T> DoubleEndedIterator for IterMut<'a, T>[src]
fn next_back(&mut self) -> Option<&'a mut T>[src]
fn nth_back(&mut self, n: usize) -> Option<Self::Item>[src]1.37.0
fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, [src]1.27.0
fn rfold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, [src]1.27.0
fn rfind<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, [src]1.27.0
impl<'_, T> ExactSizeIterator for IterMut<'_, T>[src]
impl<'_, T> FusedIterator for IterMut<'_, T>[src]1.26.0
impl<'a, T> Iterator for IterMut<'a, T>[src]
type Item = &'a mut TThe type of the elements being iterated over.
fn next(&mut self) -> Option<&'a mut T>[src]
fn size_hint(&self) -> (usize, Option<usize>)[src]
fn last(self) -> Option<&'a mut T>[src]
fn count(self) -> usize[src]
fn nth(&mut self, n: usize) -> Option<Self::Item>[src]
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;
[src]1.28.0
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>, [src]
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, [src]
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
F: FnMut(<I as Iterator>::Item) -> B,
I: Iterator,
type Item = B;
where
F: FnMut(Self::Item) -> B, [src]
fn for_each<F>(self, f: F) where
F: FnMut(Self::Item), [src]1.21.0
fn filter<P>(self, predicate: P) -> Filter<Self, P>ⓘ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, [src]
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
F: FnMut(<I as Iterator>::Item) -> Option<B>,
I: Iterator,
type Item = B;
where
F: FnMut(Self::Item) -> Option<B>, [src]
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);
[src]
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;
[src]
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, [src]
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, [src]
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>, [src]
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;
[src]
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;
[src]
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
F: FnMut(&mut St, <I as Iterator>::Item) -> Option<B>,
I: Iterator,
type Item = B;
where
F: FnMut(&mut St, Self::Item) -> Option<B>, [src]
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
F: FnMut(<I as Iterator>::Item) -> U,
I: Iterator,
U: IntoIterator,
type Item = <U as IntoIterator>::Item;
where
F: FnMut(Self::Item) -> U,
U: IntoIterator, [src]
fn flatten(self) -> Flatten<Self>ⓘNotable traits for Flatten<I>
impl<I, U> Iterator for Flatten<I> where
I: Iterator,
U: Iterator,
<I as Iterator>::Item: IntoIterator,
<<I as Iterator>::Item as IntoIterator>::IntoIter == U,
<<I as Iterator>::Item as IntoIterator>::Item == <U as Iterator>::Item,
type Item = <U as Iterator>::Item;
where
Self::Item: IntoIterator, [src]1.29.0
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;
[src]
fn inspect<F>(self, f: F) -> Inspect<Self, F>ⓘNotable traits for Inspect<I, F>
impl<I, F> Iterator for Inspect<I, F> where
F: FnMut(&<I as Iterator>::Item),
I: Iterator,
type Item = <I as Iterator>::Item;
where
F: FnMut(&Self::Item), [src]
fn by_ref(&mut self) -> &mut SelfⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
#[must_use =
"if you really need to exhaust the iterator, consider `.for_each(drop)` instead"]fn collect<B>(self) -> B where
B: FromIterator<Self::Item>, [src]
fn partition<B, F>(self, f: F) -> (B, B) where
B: Default + Extend<Self::Item>,
F: FnMut(&Self::Item) -> bool, [src]
fn partition_in_place<'a, T, P>(self, predicate: P) -> usize where
P: FnMut(&T) -> bool,
Self: DoubleEndedIterator<Item = &'a mut T>,
T: 'a, [src]
fn is_partitioned<P>(self, predicate: P) -> bool where
P: FnMut(Self::Item) -> bool, [src]
fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R where
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>, [src]1.27.0
fn try_for_each<F, R>(&mut self, f: F) -> R where
F: FnMut(Self::Item) -> R,
R: Try<Ok = ()>, [src]1.27.0
fn fold<B, F>(self, init: B, f: F) -> B where
F: FnMut(B, Self::Item) -> B, [src]
fn fold_first<F>(self, f: F) -> Option<Self::Item> where
F: FnMut(Self::Item, Self::Item) -> Self::Item, [src]
fn all<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, [src]
fn any<F>(&mut self, f: F) -> bool where
F: FnMut(Self::Item) -> bool, [src]
fn find<P>(&mut self, predicate: P) -> Option<Self::Item> where
P: FnMut(&Self::Item) -> bool, [src]
fn find_map<B, F>(&mut self, f: F) -> Option<B> where
F: FnMut(Self::Item) -> Option<B>, [src]1.30.0
fn try_find<F, R>(
&mut self,
f: F
) -> Result<Option<Self::Item>, <R as Try>::Error> where
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool>, [src]
fn position<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool, [src]
fn rposition<P>(&mut self, predicate: P) -> Option<usize> where
P: FnMut(Self::Item) -> bool,
Self: ExactSizeIterator + DoubleEndedIterator, [src]
fn max(self) -> Option<Self::Item> where
Self::Item: Ord, [src]
fn min(self) -> Option<Self::Item> where
Self::Item: Ord, [src]
fn max_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, [src]1.6.0
fn max_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]1.15.0
fn min_by_key<B, F>(self, f: F) -> Option<Self::Item> where
B: Ord,
F: FnMut(&Self::Item) -> B, [src]1.6.0
fn min_by<F>(self, compare: F) -> Option<Self::Item> where
F: FnMut(&Self::Item, &Self::Item) -> Ordering, [src]1.15.0
fn rev(self) -> Rev<Self>ⓘNotable traits for Rev<I>
impl<I> Iterator for Rev<I> where
I: DoubleEndedIterator,
type Item = <I as Iterator>::Item;
where
Self: DoubleEndedIterator, [src]
fn unzip<A, B, FromA, FromB>(self) -> (FromA, FromB) where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Iterator<Item = (A, B)>, [src]
fn copied<'a, T>(self) -> Copied<Self>ⓘNotable traits for Copied<I>
impl<'a, I, T> Iterator for Copied<I> where
I: Iterator<Item = &'a T>,
T: 'a + Copy,
type Item = T;
where
Self: Iterator<Item = &'a T>,
T: 'a + Copy, [src]1.36.0
fn cloned<'a, T>(self) -> Cloned<Self>ⓘNotable traits for Cloned<I>
impl<'a, I, T> Iterator for Cloned<I> where
I: Iterator<Item = &'a T>,
T: 'a + Clone,
type Item = T;
where
Self: Iterator<Item = &'a T>,
T: 'a + Clone, [src]
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, [src]
fn sum<S>(self) -> S where
S: Sum<Self::Item>, [src]1.11.0
fn product<P>(self) -> P where
P: Product<Self::Item>, [src]1.11.0
fn cmp<I>(self, other: I) -> Ordering where
I: IntoIterator<Item = Self::Item>,
Self::Item: Ord, [src]1.5.0
fn cmp_by<I, F>(self, other: I, cmp: F) -> Ordering where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Ordering,
I: IntoIterator, [src]
fn partial_cmp<I>(self, other: I) -> Option<Ordering> where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn partial_cmp_by<I, F>(self, other: I, partial_cmp: F) -> Option<Ordering> where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> Option<Ordering>,
I: IntoIterator, [src]
fn eq<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, [src]1.5.0
fn eq_by<I, F>(self, other: I, eq: F) -> bool where
F: FnMut(Self::Item, <I as IntoIterator>::Item) -> bool,
I: IntoIterator, [src]
fn ne<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialEq<<I as IntoIterator>::Item>, [src]1.5.0
fn lt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn le<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn gt<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn ge<I>(self, other: I) -> bool where
I: IntoIterator,
Self::Item: PartialOrd<<I as IntoIterator>::Item>, [src]1.5.0
fn is_sorted(self) -> bool where
Self::Item: PartialOrd<Self::Item>, [src]
fn is_sorted_by<F>(self, compare: F) -> bool where
F: FnMut(&Self::Item, &Self::Item) -> Option<Ordering>, [src]
fn is_sorted_by_key<F, K>(self, f: F) -> bool where
F: FnMut(Self::Item) -> K,
K: PartialOrd<K>, [src]
impl<'_, T> Send for IterMut<'_, T> where
T: Send, [src]
impl<'_, T> Sync for IterMut<'_, T> where
T: Sync, [src]
impl<'a, T> RefUnwindSafe for IterMut<'a, T> where
T: RefUnwindSafe, impl<'a, T> Unpin for IterMut<'a, T>impl<'a, T> !UnwindSafe for IterMut<'a, T>impl<T> Any for T where
T: 'static + ?Sized, [src]
impl<T> Borrow<T> for T where
T: ?Sized, [src]
fn borrow(&self) -> &TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> BorrowMut<T> for T where
T: ?Sized, [src]
fn borrow_mut(&mut self) -> &mut TⓘNotable traits for &'_ mut F
impl<'_, F> Future for &'_ mut F where
F: Unpin + Future + ?Sized,
type Output = <F as Future>::Output;
impl<'_, I> Iterator for &'_ mut I where
I: Iterator + ?Sized,
type Item = <I as Iterator>::Item;
impl<R: Read + ?Sized, '_> Read for &'_ mut R
impl<W: Write + ?Sized, '_> Write for &'_ mut W
[src]
impl<T> From<T> for T[src]
impl<T, U> Into<U> for T where
U: From<T>, [src]
impl<I> IntoIterator for I where
I: Iterator, [src]
type Item = <I as Iterator>::ItemThe type of the elements being iterated over.
type IntoIter = IWhich kind of iterator are we turning this into?
fn into_iter(self) -> I[src]
impl<T, U> TryFrom<U> for T where
U: Into<T>, [src]
type Error = InfallibleThe type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>[src]
impl<T, U> TryInto<U> for T where
U: TryFrom<T>, [src]
© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/collections/linked_list/struct.IterMut.html