Struct slice_utils::Chain

pub struct Chain<T, A, B>(pub A, pub B, _);

Two slices joined via Slice::chain.

Tuple Fields

0: A

1: B

Implementations

impl<T, A, B> Chain<T, A, B>

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

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

impl<T, A, B> Chain<T, A, B>

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

pub fn iter(&self) -> Iter<'_, T, Self>

Trait Implementations

impl<T: Clone, A: Clone, B: Clone> Clone for Chain<T, A, B>

fn clone(&self) -> Chain<T, A, B>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T, A, B> Debug for Chain<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: Hash, A: Hash, B: Hash> Hash for Chain<T, A, B>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T, A, B> Index<usize> for Chain<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 Chain<T, A, B>

where Chain<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> IntoIterator for &'a Chain<T, A, B>

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

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, Chain<T, A, B>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<'a, T, A, B> PartialEq<&'a [T]> for Chain<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 Chain<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 Chain<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: PartialEq, A: PartialEq, B: PartialEq> PartialEq for Chain<T, A, B>

fn eq(&self, other: &Chain<T, A, B>) -> 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 Chain<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 Chain<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.

impl<T: Copy, A: Copy, B: Copy> Copy for Chain<T, A, B>

impl<T: Eq, A: Eq, B: Eq> Eq for Chain<T, A, B>

impl<T, A, B> StructuralPartialEq for Chain<T, A, B>