Struct slice_utils::Interleave

pub struct Interleave<T, A, B> {
    pub left: A,
    pub right: B,
    /* private fields */
}

Two interleaved slices, from Slice::interleave.

Fields

left: A

right: B

Implementations

impl<T, A, B> Interleave<T, A, B>

where A: Slice<T>, B: Slice<T>,

pub fn new(left: A, right: B) -> Self

Trait Implementations

impl<T, A, B> Debug for Interleave<T, A, B>

where T: Debug, A: Slice<T>, B: Slice<T>,

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

Formats the value using the given formatter.

impl<T, A, B> Index<usize> for Interleave<T, A, B>

where A: Slice<T>, B: Slice<T>,

type Output = T

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, A, B> IndexMut<usize> for Interleave<T, A, B>

where Interleave<T, A, B>: SliceMut<T>, A: SliceMut<T>, B: SliceMut<T>,

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

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

impl<'a, T, A, B> PartialEq<&'a [T]> for Interleave<T, A, B>

where T: PartialEq, A: Slice<T>, B: Slice<T>,

fn eq(&self, other: &&'a [T]) -> 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<T, A, B> PartialEq<[T]> for Interleave<T, A, B>

where T: PartialEq, A: Slice<T>, B: Slice<T>,

fn eq(&self, other: &[T]) -> 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<T, A, B, const N: usize> PartialEq<[T; N]> for Interleave<T, A, B>

where T: PartialEq, A: Slice<T>, B: Slice<T>,

fn eq(&self, other: &[T; N]) -> 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<T, A, B> Slice<T> for Interleave<T, A, B>

where A: Slice<T>, B: Slice<T>,

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

Index the slice.

fn len(&self) -> usize

Returns the exact length of the slice.

fn is_empty(&self) -> bool

Whether or not the slice is empty (self.len() == 0).

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

Takes a sub-slice, returning None if the range is out-of-bounds.

fn skip(self, n: usize) -> Option<SliceOf<T, Self>>

Shortcut for .slice(n + 1..)

fn take(self, n: usize) -> Option<SliceOf<T, Self>>

Shorcut for .slice(..=n).

fn chain<O: Slice<T>>(self, other: O) -> Chain<T, Self, O>

Chains two slices together, back-to-back: the equivalent of Iterator::chain.

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

Returns an iterator over fixed-size chunks: the equivalent of slice::chunks. The last chunk may be smaller than the rest.

fn chunks_exact(&self, size: usize) -> Option<Chunks<'_, T, Self>>

Returns an iterator over fixed-size chunks. If data.len() is not divisible by size, returns None. Otherwise, equivalent to [chunks].

fn cycle(self) -> Cycle<T, Self>

Repeats the slice forever: the equivalent of Iterator::cycle.

fn interleave<O: Slice<T>>(self, other: O) -> Interleave<T, Self, O>

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

fn reverse(self) -> Reverse<T, Self>

Reverses the slice: the equivalent of Iterator::rev.

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

Returns an iterator over overlapping slices of length size: the equivalent of slice::windows.

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

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

impl<T, A, B> SliceMut<T> for Interleave<T, A, B>

where A: SliceMut<T>, B: SliceMut<T>,

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

Mutably index the slice.

fn slice_mut<R: RangeBounds<usize>>( self, range: R ) -> Option<SliceOfMut<T, Self>>

Takes a mutable sub-slice, returning None if the range is out-of-bounds.

fn map<F>(&mut self, f: F)

where F: for<'a> FnMut(&mut T),

Calls a closure on each item, mutating it.