Struct Drain 

pub(super) struct Drain<'l, 'f, T, const N: usize, F> {
    ptr: NonNull<T>,
    end: *mut T,
    f: &'f mut F,
    l: PhantomData<&'l mut [T; N]>,
}

🔬This is a nightly-only experimental API. (array_try_map #79711)

See Drain::new; this is our fake iterator.

Fields

ptr: NonNull<T>

🔬This is a nightly-only experimental API. (array_try_map #79711)

The pointer to the next element to return, or the past-the-end location if the drainer is empty.

This address will be used for all ZST elements, never changed. As we “own” this array, we dont need to store any lifetime.

end: *mut T

🔬This is a nightly-only experimental API. (array_try_map #79711)

For non-ZSTs, the non-null pointer to the past-the-end element. For ZSTs, this is null.

f: &'f mut F

🔬This is a nightly-only experimental API. (array_try_map #79711)

l: PhantomData<&'l mut [T; N]>

🔬This is a nightly-only experimental API. (array_try_map #79711)

Implementations

impl<'l, 'f, T, U, const N: usize, F: FnMut(T) -> U> Drain<'l, 'f, T, N, F>

pub(super) const unsafe fn new( array: &'l mut ManuallyDrop<[T; N]>, f: &'f mut F, ) -> Self

This function returns a function that lets you index the given array in const. As implemented it can optimize better than iterators, and can be constified. It acts like a sort of guard (owns the array) and iterator combined, which can be implemented as it is a struct that implements const fn; in that regard it is somewhat similar to an array::Iter implementing UncheckedIterator. The only method you’re really allowed to call is next(), anything else is more or less UB, hence this function being unsafe. Moved elements will not be dropped. This will also not actually store the array.

SAFETY: must only be called N times. Thou shalt not drop the array either.

Trait Implementations

impl<T, const N: usize, F> Drop for Drain<'_, '_, T, N, F>

fn drop(&mut self)

Executes the destructor for this type.

impl<T, U, const N: usize, F> FnMut(usize) for &mut Drain<'_, '_, T, N, F>

where F: FnMut(T) -> U,

extern "rust-call" fn call_mut( &mut self, (_): (usize,), ) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits #29625)

Performs the call operation.

impl<T, U, const N: usize, F> FnOnce(usize) for &mut Drain<'_, '_, T, N, F>

where F: FnMut(T) -> U,

extern "rust-call" fn call_once(self, args: (usize,)) -> Self::Output

🔬This is a nightly-only experimental API. (fn_traits #29625)

This implementation is useless.

type Output = U

The returned type after the call operator is used.