Struct slice_utils::Interleave

pub struct Interleave<S1, S2>(pub S1, pub S2);

Two interleaved slices; see Slice::interleave.

Tuple Fields

0: S1

1: S2

Trait Implementations

impl<T, S, S2> Debug for Interleave<S, S2>

where T: Debug, S: Slice<Output = T>, S2: Slice<Output = T>,

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

Formats the value using the given formatter.

impl<T, S, S2> Index<usize> for Interleave<S, S2>

where S: SliceBorrowed<Output = T>, S2: SliceBorrowed<Output = T>,

type Output = <Interleave<S, S2> as Slice>::Output

The returned type after indexing.

fn index(&self, index: usize) -> &Self::Output

Performs the indexing (container[index]) operation.

impl<T, S, S2> IndexMut<usize> for Interleave<S, S2>

where S: SliceBorrowed<Output = T> + SliceMut, S2: SliceBorrowed<Output = T> + SliceMut,

fn index_mut(&mut self, index: usize) -> &mut Self::Output

Performs the mutable indexing (container[index]) operation.

impl<T, S, O, V, S2> PartialEq<O> for Interleave<S, S2>

where V: PartialEq<T>, S: SliceOwned<Output = T>, O: Slice<Output = V>, S2: SliceOwned<Output = T>,

fn eq(&self, other: &O) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<S1, S2> Slice for Interleave<S1, S2>

where S1: Slice, S2: Slice<Output = S1::Output>,

type Output = <S1 as Slice>::Output

The type this slice returns; analagous to Index::Output.

fn len(&self) -> usize

Returns the length of the slice.

fn get_with<W: FnMut(&Self::Output) -> R, R>( &self, index: usize, f: &mut W ) -> Option<R>

Call a closure with the indicated element, returning the result or None if the index was out-of-bounds.

fn is_empty(&self) -> bool

Returns whether or not the slice is empty.

fn chain<S: Slice<Output = Self::Output>>(self, other: S) -> Chain<Self, S>

where Self: Sized,

Chains two slices together, back-to-back.

fn cycle(self) -> Cycle<Self>

where Self: Sized,

Cycles the slice infinitely.

fn interleave<S: Slice<Output = Self::Output>>( self, other: S ) -> Interleave<Self, S>

where Self: Sized,

Interleaves two slices, e.g. [A, B, A, B, …].

fn rev(self) -> Reverse<Self>

where Self: Sized,

Reverses the slice.

fn slice<R: RangeBounds<usize>>(self, range: R) -> Option<SliceOf<Self>>

where Self: Sized,

Create a sub-slice of the slice.

fn split(&self, at: usize) -> Option<(SliceOf<&Self>, SliceOf<&Self>)>

Returns (&self[..at], &self[at..]). Returns None if at is out-of-bounds.

impl<S1, S2> SliceBorrowed for Interleave<S1, S2>

where S1: SliceBorrowed, S2: SliceBorrowed<Output = S1::Output>,

fn get(&self, index: usize) -> Option<&Self::Output>

Index the slice, returning a borrowed value.

fn array_chunks<const N: usize>(&self) -> ArrayChunksBorrowed<'_, Self, N>

Return an iterator over arrays covering consecutive portions of the slice.

fn array_windows<const N: usize>(&self) -> ArrayWindowsBorrowed<'_, Self, N>

Return a slice/iterator over arrays covering overlapping portions of the slice.

fn chunks(&self, size: usize) -> ChunksBorrowed<'_, Self>

Return an iterator over slices covering consecutive portions of the slice.

fn map<F: Fn(&Self::Output) -> R, R>(self, f: F) -> MapBorrowed<Self, F>

where Self: Sized,

Call a closure on index, returning a new type.

fn iter(&self) -> IterBorrowed<'_, Self>

Creates an iterator over the slice.

fn windows(&self, size: usize) -> WindowsBorrowed<'_, Self>

Return a slice/iterator over slices covering overlapping portions of the slice.

impl<S1, S2> SliceMut for Interleave<S1, S2>

where S1: SliceMut, S2: SliceMut<Output = S1::Output>,

fn get_mut(&mut self, index: usize) -> Option<&mut Self::Output>

Index the slice, returning a mutably borrowed value.

impl<S1, S2> SliceOwned for Interleave<S1, S2>

where S1: SliceOwned, S2: SliceOwned<Output = S1::Output>,

fn get_owned(&self, index: usize) -> Option<Self::Output>

Index the slice, returning an owned value.

fn array_chunks<const N: usize>(self) -> ArrayChunksOwned<Self, N>

where Self: Sized,

Return an iterator over arrays covering consecutive portions of the slice.

fn array_windows<const N: usize>(self) -> ArrayWindowsOwned<Self, N>

where Self: Sized,

Return a slice/iterator over arrays covering overlapping portions of the slice.

fn chunks(&self, size: usize) -> ChunksOwned<'_, Self>

Return an iterator over slices covering consecutive portions of the slice.

fn map<F: Fn(Self::Output) -> R, R>(self, f: F) -> MapOwned<Self, F>

where Self: Sized,

Call a closure on index, returning a new type.

fn iter(self) -> IterOwned<Self>

where Self: Sized,

Creates an iterator over the slice.

fn try_array<const N: usize>(&self) -> Option<[Self::Output; N]>

Try to collect the slice into an array, failing if the lengths don’t match up.

fn windows(&self, size: usize) -> WindowsOwned<'_, Self>

Return a slice/iterator over slices covering overlapping portions of the slice.

fn zip<O: SliceOwned>(self, other: O) -> Zip<Self, O>

where Self: Sized,

Zip two slices into a single slice, where indexing returns a tuple of their items.