Struct MapBorrowed

pub struct MapBorrowed<S, F>(pub S, pub F);

Maps using a closure on index; see SliceBorrowed::map.

Tuple Fields

0: S

1: F

Trait Implementations

impl<S: Clone, F: Clone> Clone for MapBorrowed<S, F>

fn clone(&self) -> MapBorrowed<S, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T, S, F, U> Debug for MapBorrowed<S, F>

where S: SliceBorrowed<Output = T>, F: Fn(&T) -> U, U: Debug,

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

Formats the value using the given formatter.

impl<S: Hash, F: Hash> Hash for MapBorrowed<S, F>

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, S, O, F, U, V> PartialEq<O> for MapBorrowed<S, F>

where S: SliceBorrowed<Output = T>, O: Slice<Output = V>, F: Fn(&T) -> U, V: PartialEq<U>,

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, F, U> Slice for MapBorrowed<S, F>

where S: SliceBorrowed, F: Fn(&S::Output) -> U,

type Output = U

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<S, F, U> SliceOwned for MapBorrowed<S, F>

where S: SliceBorrowed, F: Fn(&S::Output) -> U,

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

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: Copy, F: Copy> Copy for MapBorrowed<S, F>