Struct PolymorphicIter

pub(super) struct PolymorphicIter<DATA>
where
    DATA: PartialDrop + ?Sized,
{
    alive: IndexRange,
    data: DATA,
}

The internals of a by-value array iterator.

The real array::IntoIter<T, N> stores a PolymorphicIter<[MaybeUninit<T>, N]> which it unsizes to PolymorphicIter<[MaybeUninit<T>]> to iterate.

Fields

alive: IndexRange

The elements in data that have not been yielded yet.

Invariants:

• alive.end <= N

(And the IndexRange type requires alive.start <= alive.end.)

data: DATA

This is the array we are iterating over.

Elements with index i where alive.start <= i < alive.end have not been yielded yet and are valid array entries. Elements with indices i < alive.start or i >= alive.end have been yielded already and must not be accessed anymore! Those dead elements might even be in a completely uninitialized state!

So the invariants are:

• data[alive] is alive (i.e. contains valid elements)
• data[..alive.start] and data[alive.end..] are dead (i.e. the elements were already read and must not be touched anymore!)

Implementations

impl<DATA> PolymorphicIter<DATA>

where DATA: PartialDrop + ?Sized,

pub(super) const fn len(&self) -> usize

impl<T, const N: usize> PolymorphicIter<[MaybeUninit<T>; N]>

pub(super) const fn empty() -> Self

pub(super) const unsafe fn new_unchecked( alive: IndexRange, data: [MaybeUninit<T>; N], ) -> Self

Safety

data[alive] are all initialized.

impl<T> PolymorphicIter<[MaybeUninit<T>]>

pub(super) fn as_slice(&self) -> &[T]

pub(super) fn as_mut_slice(&mut self) -> &mut [T]

impl<T> PolymorphicIter<[MaybeUninit<T>]>

Iterator-equivalent methods.

We don’t implement the actual iterator traits because we want to implement things like try_fold that require Self: Sized (which we’re not).

pub(super) fn next(&mut self) -> Option<T>

pub(super) fn size_hint(&self) -> (usize, Option<usize>)

pub(super) fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

pub(super) fn fold<B>(&mut self, init: B, f: impl FnMut(B, T) -> B) -> B

pub(super) fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where F: FnMut(B, T) -> R, R: Try<Output = B>,

pub(super) fn next_back(&mut self) -> Option<T>

pub(super) fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

pub(super) fn rfold<B>(&mut self, init: B, f: impl FnMut(B, T) -> B) -> B

pub(super) fn try_rfold<B, F, R>(&mut self, init: B, f: F) -> R

where F: FnMut(B, T) -> R, R: Try<Output = B>,

Trait Implementations

impl<T: Clone, const N: usize> Clone for PolymorphicIter<[MaybeUninit<T>; N]>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for PolymorphicIter<[MaybeUninit<T>]>

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

Formats the value using the given formatter.

impl<DATA> Drop for PolymorphicIter<DATA>

where DATA: PartialDrop + ?Sized,

fn drop(&mut self)

Executes the destructor for this type.