Struct ArraySeq

pub struct ArraySeq<T, const N: usize> { /* private fields */ }

Trait Implementations

impl<T, const N: usize> Sequence for ArraySeq<T, N>

where Const<N>: ToUInt,

type Item = T

type Iter = IntoIter<T, N>

type MinSize = StaticSize<<Const<N> as ToUInt>::Output>

The minimum size of the sequence.

type MaxSize = StaticSize<<Const<N> as ToUInt>::Output>

The maximum size of the sequence.

fn into_iter(self) -> Self::Iter

Converts this sequence into a (stateful) iterator.

fn min_size(&self) -> SizeKind

Returns the minimum size of the sequence.

fn max_size(&self) -> SizeKind

Returns the maximum size of the sequence.

const MIN_SIZE: Option<SizeKind> = <Self::MinSize>::STATIC_SIZE

const MAX_SIZE: Option<SizeKind> = <Self::MaxSize>::STATIC_SIZE

fn collect_array<const N: usize>(self) -> [Self::Item; N]

where Self: Sized + WithLowerBound<N>, Const<N>: ToUInt,

Collects this sequence’s elements into an array.

fn collect_array_in_place<const N: usize>( self, out: &mut MaybeUninit<[Self::Item; N]>, )

where Self: Sized + WithLowerBound<N>, Const<N>: ToUInt,

Collects this sequence’s elements into an array in place.

fn map<F, B>(self, f: F) -> Map<Self, F>

where Self: Sized, F: FnMut(Self::Item) -> B,

Returns a new sequence that transforms every element of the original sequence using f.

fn flat_map<F, U>(self, f: F) -> FlatMap<Self, F>

where Self: Sized, U: Sequence, F: FnMut(Self::Item) -> U,

Returns a new sequence that transforms every element of the original sequence by calling f and then “flattening” the result.

fn flatten<U>(self) -> Flatten<Self>

where Self: Sequence<Item = U> + Sized, U: Sequence,

“Flattens” the sequence by removing one nesting layer.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Returns a new sequence that yields the current iteration index together with every element.

fn take_exact_stn<N: Unsigned>(self) -> TakeExactSTn<Self, N>

where Self: Sized,

Returns a new sequence that always yields the first exactly N elements.

fn take_exact_s<const N: usize>(self) -> TakeExactS<Self, N>

where Self: Sized, Const<N>: ToUInt,

Returns a new sequence that always yields the first exactly N elements.