Struct slice_utils::FromFn

pub struct FromFn<F> {
    pub f: F,
    /* private fields */
}

A slice calling a closure on index; see from_fn.

Fields

f: F

The inner closure of the slice.

Implementations

impl<F, T> FromFn<F>

where F: Fn(usize) -> Option<T>,

pub fn new(f: F, len: Option<usize>) -> Self

Create a slice from a closure; see from_fn.

Trait Implementations

impl<F: Clone> Clone for FromFn<F>

fn clone(&self) -> FromFn<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F, T> Debug for FromFn<F>

where F: Fn(usize) -> Option<T>, T: Debug,

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

Formats the value using the given formatter.

impl<F: Hash> Hash for FromFn<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, O, F, U> PartialEq<O> for FromFn<F>

where O: Slice<Output = U>, F: Fn(usize) -> Option<T>, U: PartialEq<T>,

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

where F: Fn(usize) -> Option<T>,

type Output = T

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<F, T> SliceOwned for FromFn<F>

where F: Fn(usize) -> Option<T>,

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<F: Copy> Copy for FromFn<F>