Struct Flatten

struct Flatten<I: Iterator<Item: IntoIterator>> { ... }

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.

Implementations

impl<I> Default for Flatten<I>

fn default() -> Self

Creates a Flatten iterator from the default value of I.

# use core::slice;
# use std::iter::Flatten;
let iter: Flatten<slice::Iter<'_, [u8; 4]>> = Default::default();
assert_eq!(iter.count(), 0);

impl<I> Freeze for Flatten<I>

impl<I> IntoIterator for Flatten<I>

fn into_iter(self: Self) -> I

impl<I> RefUnwindSafe for Flatten<I>

impl<I> Send for Flatten<I>

impl<I> Sync for Flatten<I>

impl<I> TrustedLen for Flatten<I>

impl<I> Unpin for Flatten<I>

impl<I> UnsafeUnpin for Flatten<I>

impl<I> UnwindSafe for Flatten<I>

impl<I, U> Clone for Flatten<I>

fn clone(self: &Self) -> Self

impl<I, U> Debug for Flatten<I>

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

impl<I, U> DoubleEndedIterator for Flatten<I>

fn next_back(self: &mut Self) -> Option<<U as >::Item>
fn try_rfold<Acc, Fold, R>(self: &mut Self, init: Acc, fold: Fold) -> R
where
    Self: Sized,
    Fold: FnMut(Acc, <Self as >::Item) -> R,
    R: Try<Output = Acc>
fn rfold<Acc, Fold>(self: Self, init: Acc, fold: Fold) -> Acc
where
    Fold: FnMut(Acc, <Self as >::Item) -> Acc
fn advance_back_by(self: &mut Self, n: usize) -> Result<(), NonZero<usize>>

impl<I, U> FusedIterator for Flatten<I>

impl<I, U> Iterator for Flatten<I>

fn next(self: &mut Self) -> Option<<U as >::Item>
fn size_hint(self: &Self) -> (usize, Option<usize>)
fn try_fold<Acc, Fold, R>(self: &mut Self, init: Acc, fold: Fold) -> R
where
    Self: Sized,
    Fold: FnMut(Acc, <Self as >::Item) -> R,
    R: Try<Output = Acc>
fn fold<Acc, Fold>(self: Self, init: Acc, fold: Fold) -> Acc
where
    Fold: FnMut(Acc, <Self as >::Item) -> Acc
fn advance_by(self: &mut Self, n: usize) -> Result<(), NonZero<usize>>
fn count(self: Self) -> usize
fn last(self: Self) -> Option<<Self as >::Item>

impl<T> Any for Flatten<I>

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for Flatten<I>

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for Flatten<I>

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for Flatten<I>

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for Flatten<I>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into for Flatten<I>

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for Flatten<I>

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for Flatten<I>

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>