Enum CollectArrayResult

pub enum CollectArrayResult<T, const N: usize> {
    Ok([T; N]),
    TooManyElements {
        values: [T; N],
        next_value: T,
    },
    NotEnoughElements {
        values: [MaybeUninit<T>; N],
        init_count: usize,
    },
}

The result of collecting an Iterator into an exactly-sized array, or having failed to.

More than N elements may be consumed from the Iterator - if this is undesirable, consider calling Iterator before collecting.

Variants

Ok([T; N])

Returned if the Iterator contained exactly N elements.

TooManyElements

Returned if the Iterator contained more than N elements. The underlying Iterator may not be exhausted, and remaining values may not be accessible.

Fields

values: [T; N]

The N values which were read.

next_value: T

The next value after the Nth.

NotEnoughElements

Returned if the Iterator contained fewer than N elements.

Safety

Only the first init_count elements will be init, the remaining elements must not be read.

Fields

values: [MaybeUninit<T>; N]

The consumed values, only init_count of which will be init.

init_count: usize

How many elements in values are init.

Implementations

impl<T, const N: usize> CollectArrayResult<T, N>

pub fn unwrap(self) -> [T; N]

Returns the contained Ok value, consuming the self value.

Trait Implementations

impl<T, const N: usize> Debug for CollectArrayResult<T, N>

where T: Debug,

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

Formats the value using the given formatter.

impl<T, const N: usize> Drop for CollectArrayResult<T, N>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, const N: usize> FromIterator<T> for CollectArrayResult<T, N>

fn from_iter<It: IntoIterator<Item = T>>(it: It) -> Self

Creates a value from an iterator.

impl<T, const N: usize> PartialEq for CollectArrayResult<T, N>

where T: PartialEq,

fn eq(&self, other: &CollectArrayResult<T, N>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.