Trait slice_utils::SliceOwned

pub trait SliceOwned: Slice {
    // Required method
    fn get_owned(&self, index: usize) -> Option<Self::Output>;

    // Provided methods
    fn array_chunks<const N: usize>(self) -> ArrayChunksOwned<Self, N> 
       where Self: Sized { ... }
    fn array_windows<const N: usize>(self) -> ArrayWindowsOwned<Self, N> 
       where Self: Sized { ... }
    fn chunks(&self, size: usize) -> ChunksOwned<'_, Self>  { ... }
    fn map<F: Fn(Self::Output) -> R, R>(self, f: F) -> MapOwned<Self, F>
       where Self: Sized { ... }
    fn iter(self) -> IterOwned<Self> 
       where Self: Sized { ... }
    fn try_array<const N: usize>(&self) -> Option<[Self::Output; N]> { ... }
    fn windows(&self, size: usize) -> WindowsOwned<'_, Self>  { ... }
    fn zip<O: SliceOwned>(self, other: O) -> Zip<Self, O>
       where Self: Sized { ... }
}

A Slice that can return owned values.

Required Methods

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

Index the slice, returning an owned value.

Provided Methods

fn array_chunks<const N: usize>(self) -> ArrayChunksOwned<Self, N>

where Self: Sized,

Return an iterator over arrays covering consecutive portions of the slice.

Analagous to slice::array_chunks.

Panics

If N == 0, panics.

Examples

let slice = [1, 2, 3, 4, 5];
let mut iter = slice.array_chunks::<2>();

assert_eq!(iter.next(), Some([1, 2]));
assert_eq!(iter.next(), Some([3, 4]));
assert!(iter.next().is_none());
assert_eq!(iter.remainder(), [5]);

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.

Analagous to slice::array_windows.

Panics

If N == 0, panics.

Examples

let slice = [1, 2, 3, 4, 5];
let mut windows = slice.array_windows::<3>();

assert_eq!(windows.next(), Some([1, 2, 3]));
assert_eq!(windows.next(), Some([2, 3, 4]));
assert_eq!(windows.next(), Some([3, 4, 5]));
assert!(windows.next().is_none());
assert_eq!(windows.get_owned(1), Some([2, 3, 4]));

fn chunks(&self, size: usize) -> ChunksOwned<'_, Self>

Return an iterator over slices covering consecutive portions of the slice.

Analagous to slice::chunks.

Panics

If size == 0, panics.

Examples

let slice = [1, 2, 3, 4, 5];
let mut iter = slice.chunks(2);

assert_eq!(iter.next().unwrap(), [1, 2]);
assert_eq!(iter.next().unwrap(), [3, 4]);
assert_eq!(iter.next().unwrap(), [5]);
assert!(iter.next().is_none());

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.

Analagous to Iterator::map.

Examples

let slice = [0, 1, 2].map(|x| x != 0);
assert_eq!(slice, [false, true, true]);

fn iter(self) -> IterOwned<Self>

where Self: Sized,

Creates an iterator over the slice.

Examples

let slice = [1, 2].chain([3]);
let mut iter = slice.iter();
assert_eq!(iter.next(), Some(1));
assert_eq!(iter.next(), Some(2));
assert_eq!(iter.next(), Some(3));
assert!(iter.next().is_none());

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.

Examples

let slice = [1, 2, 3].map(|i| i * i);
let arr: [i32; 3] = slice.try_array().unwrap();
assert_eq!(arr, [1, 4, 9]);

fn windows(&self, size: usize) -> WindowsOwned<'_, Self>

Return a slice/iterator over slices covering overlapping portions of the slice.

Analagous to slice::windows.

Panics

If size == 0, panics.

Examples

let slice = [1, 2, 3, 4, 5];
let mut windows = slice.windows(3);

assert_eq!(windows.next().unwrap(), [1, 2, 3]);
assert_eq!(windows.next().unwrap(), [2, 3, 4]);
assert_eq!(windows.next().unwrap(), [3, 4, 5]);
assert!(windows.next().is_none());
assert_eq!(windows.get_owned(1).unwrap(), [2, 3, 4]);

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.

Analagous to Iterator::zip.

Examples

let a = [1, 2, 3];
let b = [4, 5, 6, 7];
let slice = a.zip(b);

assert_eq!(
    slice,
    [
        (1, 4),
        (2, 5),
        (3, 6),
    ]
);

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl<'a, S> SliceOwned for &'a S

where S: SliceOwned + ?Sized,

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

impl<'a, S> SliceOwned for &'a mut S

where S: SliceOwned + ?Sized,

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

impl<T> SliceOwned for [T]

where T: Copy,

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

impl<T> SliceOwned for Range<T>

where T: Clone, Range<T>: Iterator<Item = T>,

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

impl<T> SliceOwned for RangeFrom<T>

where T: Clone, RangeFrom<T>: Iterator<Item = T>,

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

impl<T> SliceOwned for RangeInclusive<T>

where T: Clone, RangeInclusive<T>: Iterator<Item = T>,

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

impl<T, const N: usize> SliceOwned for [T; N]

where T: Copy,

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

Implementors

impl<'a, S> SliceOwned for WindowsBorrowed<'a, S>

where S: SliceBorrowed + ?Sized,

impl<'a, S> SliceOwned for WindowsOwned<'a, S>

where S: SliceOwned + ?Sized,

impl<'a, S, const N: usize> SliceOwned for ArrayWindowsBorrowed<'a, S, N>

where S: SliceBorrowed + ?Sized,

impl<A> SliceOwned for SliceOf<A>

where A: SliceOwned,

impl<A> SliceOwned for SplitMut<'_, A>

where A: SliceOwned + ?Sized,

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

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

impl<S1, S2> SliceOwned for Chain<S1, S2>

where S1: SliceOwned, S2: SliceOwned<Output = S1::Output>,

impl<S1, S2> SliceOwned for Interleave<S1, S2>

where S1: SliceOwned, S2: SliceOwned<Output = S1::Output>,

impl<S1, S2> SliceOwned for Zip<S1, S2>

where S1: SliceOwned, S2: SliceOwned,

impl<S> SliceOwned for Cycle<S>

where S: SliceOwned,

impl<S> SliceOwned for Reverse<S>

where S: SliceOwned,

impl<S, F, U> SliceOwned for MapBorrowed<S, F>

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

impl<S, F, U> SliceOwned for MapOwned<S, F>

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

impl<S, const N: usize> SliceOwned for ArrayWindowsOwned<S, N>

where S: SliceOwned + Sized,