Struct Reverse

pub struct Reverse<S>(pub S);

A reversed slice; see Slice::rev.

Tuple Fields

0: S

Trait Implementations

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

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

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

Formats the value using the given formatter.

impl<T, S> Index<usize> for Reverse<S>

where S: SliceBorrowed<Output = T>,

type Output = <Reverse<S> as Slice>::Output

The returned type after indexing.

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

Performs the indexing (container[index]) operation.

impl<T, S> IndexMut<usize> for Reverse<S>

where S: 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> PartialEq<O> for Reverse<S>

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<S> Slice for Reverse<S>

where S: Slice,

type Output = <S 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<F: FnMut(&Self::Output) -> U, U>( &self, index: usize, f: &mut F, ) -> Option<U>

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<S> SliceBorrowed for Reverse<S>

where S: SliceBorrowed,

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 cloned(self) -> Cloned<Self>

where Self: Sized, Self::Output: Clone,

Create a new slice that clones each value on access. Analagous to self.map(Clone::clone).

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<S> SliceMut for Reverse<S>

where S: SliceMut,

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

Index the slice, returning a mutably borrowed value.

fn split_mut( &mut self, at: usize, ) -> Option<(SplitMut<'_, Self>, SplitMut<'_, Self>)>

where Self: Unique,

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

fn copy_from_slice<S>(&mut self, src: &S)

where S: Slice<Output = Self::Output>, S::Output: Clone,

Copy all the items from src into self.

impl<S> SliceOwned for Reverse<S>

where S: SliceOwned,

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.

impl<S> Unique for Reverse<S>

where S: Unique,