1.29.0[−][src]Struct core::iter::Flatten  
An iterator that flattens one level of nesting in an iterator of things that can be turned into iterators.
This struct is created by the flatten method on Iterator. See its
documentation for more.
Trait Implementations
impl<I, U> Clone for Flatten<I> where
    I: Clone + Iterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
    U: Clone + Iterator, [src]
I: Clone + Iterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
U: Clone + Iterator,
fn clone(&self) -> Self[src]
fn clone_from(&mut self, source: &Self)1.0.0[src]
impl<I, U> Debug for Flatten<I> where
    I: Debug + Iterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
    U: Debug + Iterator, [src]
I: Debug + Iterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
U: Debug + Iterator,
impl<I, U> DoubleEndedIterator for Flatten<I> where
    I: DoubleEndedIterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
    U: DoubleEndedIterator, [src]
I: DoubleEndedIterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
U: DoubleEndedIterator,
fn next_back(&mut self) -> Option<U::Item>[src]
fn try_rfold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
    Self: Sized,
    Fold: FnMut(Acc, Self::Item) -> R,
    R: Try<Ok = Acc>, [src]
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
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 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, U> FusedIterator for Flatten<I> where
    I: FusedIterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
    U: Iterator, [src]
I: FusedIterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
U: Iterator,
impl<I, U> Iterator for Flatten<I> where
    I: Iterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
    U: Iterator, [src]
I: Iterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>,
U: Iterator,
type Item = U::Item
The type of the elements being iterated over.
fn next(&mut self) -> Option<U::Item>[src]
fn size_hint(&self) -> (usize, Option<usize>)[src]
fn try_fold<Acc, Fold, R>(&mut self, init: Acc, fold: Fold) -> R where
    Self: Sized,
    Fold: FnMut(Acc, Self::Item) -> R,
    R: Try<Ok = Acc>, [src]
Self: Sized,
Fold: FnMut(Acc, Self::Item) -> R,
R: Try<Ok = Acc>,
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 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, [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_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 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<I> Send for Flatten<I> where
    I: Send,
    <<I as Iterator>::Item as IntoIterator>::IntoIter: Send, 
I: Send,
<<I as Iterator>::Item as IntoIterator>::IntoIter: Send,
impl<I> Sync for Flatten<I> where
    I: Sync,
    <<I as Iterator>::Item as IntoIterator>::IntoIter: Sync, 
I: Sync,
<<I as Iterator>::Item as IntoIterator>::IntoIter: Sync,
impl<I> Unpin for Flatten<I> where
    I: Unpin,
    <<I as Iterator>::Item as IntoIterator>::IntoIter: Unpin, 
I: Unpin,
<<I as Iterator>::Item as IntoIterator>::IntoIter: 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>,