Struct slice_utils::Reverse

pub struct Reverse<T, A>(pub A, _);

A reversed slice, from Slice::reverse.

Tuple Fields

0: A

Implementations

impl<T, A> Reverse<T, A>

where A: Slice<T>,

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

impl<T, A> Reverse<T, A>

where A: Slice<T>,

pub fn new(data: A) -> Self

Trait Implementations

impl<T: Clone, A: Clone> Clone for Reverse<T, A>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, A> Debug for Reverse<T, A>

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

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

Formats the value using the given formatter.

impl<T: Hash, A: Hash> Hash for Reverse<T, A>

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> Index<usize> for Reverse<T, A>

where A: 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> IndexMut<usize> for Reverse<T, A>

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

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

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

impl<'a, T, A> IntoIterator for &'a Reverse<T, A>

where A: Slice<T>,

type Item = &'a T

The type of the elements being iterated over.

type IntoIter = Iter<'a, T, Reverse<T, A>>

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> PartialEq<&'a [T]> for Reverse<T, A>

where T: PartialEq, A: 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> PartialEq<[T]> for Reverse<T, A>

where T: PartialEq, A: 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, const N: usize> PartialEq<[T; N]> for Reverse<T, A>

where T: PartialEq, A: 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> PartialEq for Reverse<T, A>

fn eq(&self, other: &Reverse<T, A>) -> 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> Slice<T> for Reverse<T, A>

where A: 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 array_chunks<const N: usize>(&self) -> ArrayChunks<'_, T, Self, N>

Returns an iterator over const-size chunks: the equivalent of slice::array_chunks. All the chunks are guaranteed to be the same size: items at the end will be skipped if there aren’t enough to fill a chunk.

fn array_chunks_exact<const N: usize>( &self ) -> Option<ArrayChunks<'_, T, Self, N>>

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

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

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

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> SliceMut<T> for Reverse<T, A>

where A: 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> Copy for Reverse<T, A>

impl<T: Eq, A: Eq> Eq for Reverse<T, A>

impl<T, A> StructuralPartialEq for Reverse<T, A>