1.34.0[−][src]Struct core::iter::Successors  
An new iterator where each successive item is computed based on the preceding one.
This struct is created by the successors function.
See its documentation for more.
Trait Implementations
impl<T: Clone, F: Clone> Clone for Successors<T, F>[src]
fn clone(&self) -> Successors<T, F>[src]
fn clone_from(&mut self, source: &Self)1.0.0[src]
impl<T: Debug, F> Debug for Successors<T, F>[src]
impl<T, F> FusedIterator for Successors<T, F> where
    F: FnMut(&T) -> Option<T>, [src]
F: FnMut(&T) -> Option<T>,
impl<T, F> Iterator for Successors<T, F> where
    F: FnMut(&T) -> Option<T>, [src]
F: FnMut(&T) -> Option<T>,
type Item = T
The type of the elements being iterated over.
fn next(&mut self) -> Option<Self::Item>[src]
fn size_hint(&self) -> (usize, Option<usize>)[src]
fn count(self) -> usize where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn last(self) -> Option<Self::Item> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn nth(&mut self, n: usize) -> Option<Self::Item>1.0.0[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>, 1.0.0[src]
Self: Sized,
U: IntoIterator<Item = Self::Item>,
fn zip<U>(self, other: U) -> Zip<Self, U::IntoIter> where
    Self: Sized,
    U: IntoIterator, 1.0.0[src]
Self: Sized,
U: IntoIterator,
fn map<B, F>(self, f: F) -> Map<Self, F> where
    Self: Sized,
    F: FnMut(Self::Item) -> B, 1.0.0[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, 1.0.0[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>, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> Option<B>,
fn enumerate(self) -> Enumerate<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn peekable(self) -> Peekable<Self> where
    Self: Sized, 1.0.0[src]
Self: Sized,
fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P> where
    Self: Sized,
    P: FnMut(&Self::Item) -> bool, 1.0.0[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, 1.0.0[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, 1.0.0[src]
Self: Sized,
fn take(self, n: usize) -> Take<Self> where
    Self: Sized, 1.0.0[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>, 1.0.0[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, 1.0.0[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, 1.0.0[src]
Self: Sized,
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
    Self: Sized,
    F: FnMut(&Self::Item), 1.0.0[src]
Self: Sized,
F: FnMut(&Self::Item),
fn by_ref(&mut self) -> &mut Self where
    Self: Sized, 1.0.0[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, 1.0.0[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, 1.0.0[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_fold<B, F, R>(&mut self, init: B, f: F) -> R where
    Self: Sized,
    F: FnMut(B, Self::Item) -> R,
    R: Try<Ok = B>, 1.27.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> R,
R: Try<Ok = B>,
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 fold<B, F>(self, init: B, f: F) -> B where
    Self: Sized,
    F: FnMut(B, Self::Item) -> B, 1.0.0[src]
Self: Sized,
F: FnMut(B, Self::Item) -> B,
fn fold_first<F>(self, f: F) -> Option<Self::Item> where
    Self: Sized,
    F: FnMut(Self::Item, Self::Item) -> Self::Item, [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, 1.0.0[src]
Self: Sized,
F: FnMut(Self::Item) -> bool,
fn any<F>(&mut self, f: F) -> bool where
    Self: Sized,
    F: FnMut(Self::Item) -> bool, 1.0.0[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, 1.0.0[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, E, R>(&mut self, f: F) -> Result<Option<Self::Item>, E> where
    Self: Sized,
    F: FnMut(&Self::Item) -> R,
    R: Try<Ok = bool, Error = E>, [src]
Self: Sized,
F: FnMut(&Self::Item) -> R,
R: Try<Ok = bool, Error = E>,
fn position<P>(&mut self, predicate: P) -> Option<usize> where
    Self: Sized,
    P: FnMut(Self::Item) -> bool, 1.0.0[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, 1.0.0[src]
P: FnMut(Self::Item) -> bool,
Self: Sized + ExactSizeIterator + DoubleEndedIterator,
fn max(self) -> Option<Self::Item> where
    Self: Sized,
    Self::Item: Ord, 1.0.0[src]
Self: Sized,
Self::Item: Ord,
fn min(self) -> Option<Self::Item> where
    Self: Sized,
    Self::Item: Ord, 1.0.0[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, 1.0.0[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)>, 1.0.0[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, 1.0.0[src]
Self: Sized + Iterator<Item = &'a T>,
T: Clone,
fn cycle(self) -> Cycle<Self> where
    Self: Sized + Clone, 1.0.0[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,
Auto Trait Implementations
impl<T, F> Send for Successors<T, F> where
    F: Send,
    T: Send, 
F: Send,
T: Send,
impl<T, F> Sync for Successors<T, F> where
    F: Sync,
    T: Sync, 
F: Sync,
T: Sync,
impl<T, F> Unpin for Successors<T, F> where
    F: Unpin,
    T: Unpin, 
F: Unpin,
T: 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,
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.
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>,