Struct Flatten

#[must_use = "iterators are lazy and do nothing unless consumed"]
pub struct Flatten<I: Iterator<Item: IntoIterator>> { pub(in ::iter::adapters::flatten) inner: FlattenCompat<I, <I::Item as IntoIterator>::IntoIter> }

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.

Fields

inner: FlattenCompat<I, <I::Item as IntoIterator>::IntoIter>

Implementations

impl<I: ~const Iterator<Item: IntoIterator>> Flatten<I>

const fn new(iter: I) -> Flatten<I>

Trait Implementations

impl<I> Default for Flatten<I> where I: Default + Iterator<Item: IntoIterator>,

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> SourceIter for Flatten<I> where I: SourceIter + TrustedFused + Iterator, <I as Iterator>::Item: IntoIterator,

type Source = <I as SourceIter>::Source;
unsafe fn as_inner(&mut self) -> &mut I::Source

impl<I> TrustedLen for Flatten<I> where I: Iterator<Item: IntoIterator>, FlattenCompat<I, <I::Item as IntoIterator>::IntoIter>: TrustedLen,

impl<I, U> Clone for Flatten<I> where I: Clone + Iterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>, U: Clone + Iterator,

fn clone(&self) -> Self

impl<I, U> Debug for Flatten<I> where I: Debug + Iterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>, U: Debug + Iterator,

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

impl<I, U> DoubleEndedIterator for Flatten<I> where I: DoubleEndedIterator<Item: IntoIterator<IntoIter = U, Item = U::Item>>, U: DoubleEndedIterator,

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

impl<I, U> FusedIterator for Flatten<I> where 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,

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

Auto Trait Implementations

impl<I> Freeze for Flatten<I> where FlattenCompat<I, <<I as Iterator>::Item as IntoIterator>::IntoIter>: Freeze,

impl<I> RefUnwindSafe for Flatten<I> where FlattenCompat<I, <<I as Iterator>::Item as IntoIterator>::IntoIter>: RefUnwindSafe,

impl<I> Send for Flatten<I> where FlattenCompat<I, <<I as Iterator>::Item as IntoIterator>::IntoIter>: Send,

impl<I> Sync for Flatten<I> where FlattenCompat<I, <<I as Iterator>::Item as IntoIterator>::IntoIter>: Sync,

impl<I> Unpin for Flatten<I> where FlattenCompat<I, <<I as Iterator>::Item as IntoIterator>::IntoIter>: Unpin,

impl<I> UnsafeUnpin for Flatten<I> where FlattenCompat<I, <<I as Iterator>::Item as IntoIterator>::IntoIter>: UnsafeUnpin,

impl<I> UnwindSafe for Flatten<I> where FlattenCompat<I, <<I as Iterator>::Item as IntoIterator>::IntoIter>: UnwindSafe,

Blanket Implementations

impl<I> IntoIterator for Flatten<I> where I: Iterator,

type Item = <I as Iterator>::Item;
type IntoIter = I;
fn into_iter(self) -> I

impl<T> Any for Flatten<I> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Flatten<I> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Flatten<I> where T: ?Sized,

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

impl<T> CloneToUninit for Flatten<I> where T: Clone,

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

impl<T> From<T> for Flatten<I>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for Flatten<I> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for Flatten<I>

impl<T, U> Into<U> for Flatten<I> where U: From<T>,

fn into(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<U> for Flatten<I> where U: Into<T>,

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

impl<T, U> TryInto<U> for Flatten<I> where U: TryFrom<T>,

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