Trait core::slice::SliceExt [−] [src]

pub trait SliceExt {
    type Item;
    fn split_at(&self, mid: usize) -> (&[Self::Item], &[Self::Item]);

    fn iter(&self) -> Iter<Self::Item>;

    fn split<P>(&self, pred: P) -> Split<Self::Item, P>
    where
        P: FnMut(&Self::Item) -> bool;

    fn rsplit<P>(&self, pred: P) -> RSplit<Self::Item, P>
    where
        P: FnMut(&Self::Item) -> bool;

    fn splitn<P>(&self, n: usize, pred: P) -> SplitN<Self::Item, P>
    where
        P: FnMut(&Self::Item) -> bool;

    fn rsplitn<P>(&self, n: usize, pred: P) -> RSplitN<Self::Item, P>
    where
        P: FnMut(&Self::Item) -> bool;

    fn windows(&self, size: usize) -> Windows<Self::Item>;

    fn chunks(&self, size: usize) -> Chunks<Self::Item>;

    fn get<I>(&self, index: I) -> Option<&I::Output>
    where
        I: SliceIndex<Self>;

    fn first(&self) -> Option<&Self::Item>;

    fn split_first(&self) -> Option<(&Self::Item, &[Self::Item])>;

    fn split_last(&self) -> Option<(&Self::Item, &[Self::Item])>;

    fn last(&self) -> Option<&Self::Item>;

    unsafe fn get_unchecked<I>(&self, index: I) -> &I::Output
    where
        I: SliceIndex<Self>;

    fn as_ptr(&self) -> *const Self::Item;

    fn binary_search(&self, x: &Self::Item) -> Result<usize, usize>
    where
        Self::Item: Ord;

    fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
    where
        F: FnMut(&'a Self::Item) -> Ordering;

    fn binary_search_by_key<'a, B, F>(
        &'a self, 
        b: &B, 
        f: F
    ) -> Result<usize, usize>
    where
        F: FnMut(&'a Self::Item) -> B,
        B: Ord;

    fn len(&self) -> usize;

    fn get_mut<I>(&mut self, index: I) -> Option<&mut I::Output>
    where
        I: SliceIndex<Self>;

    fn iter_mut(&mut self) -> IterMut<Self::Item>;

    fn first_mut(&mut self) -> Option<&mut Self::Item>;

    fn split_first_mut(
        &mut self
    ) -> Option<(&mut Self::Item, &mut [Self::Item])>;

    fn split_last_mut(&mut self) -> Option<(&mut Self::Item, &mut [Self::Item])>;

    fn last_mut(&mut self) -> Option<&mut Self::Item>;

    fn split_mut<P>(&mut self, pred: P) -> SplitMut<Self::Item, P>
    where
        P: FnMut(&Self::Item) -> bool;

    fn rsplit_mut<P>(&mut self, pred: P) -> RSplitMut<Self::Item, P>
    where
        P: FnMut(&Self::Item) -> bool;

    fn splitn_mut<P>(&mut self, n: usize, pred: P) -> SplitNMut<Self::Item, P>
    where
        P: FnMut(&Self::Item) -> bool;

    fn rsplitn_mut<P>(&mut self, n: usize, pred: P) -> RSplitNMut<Self::Item, P>
    where
        P: FnMut(&Self::Item) -> bool;

    fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<Self::Item>;

    fn swap(&mut self, a: usize, b: usize);

    fn split_at_mut(
        &mut self, 
        mid: usize
    ) -> (&mut [Self::Item], &mut [Self::Item]);

    fn reverse(&mut self);

    unsafe fn get_unchecked_mut<I>(&mut self, index: I) -> &mut I::Output
    where
        I: SliceIndex<Self>;

    fn as_mut_ptr(&mut self) -> *mut Self::Item;

    fn contains(&self, x: &Self::Item) -> bool
    where
        Self::Item: PartialEq;

    fn starts_with(&self, needle: &[Self::Item]) -> bool
    where
        Self::Item: PartialEq;

    fn ends_with(&self, needle: &[Self::Item]) -> bool
    where
        Self::Item: PartialEq;

    fn rotate(&mut self, mid: usize);

    fn clone_from_slice(&mut self, src: &[Self::Item])
    where
        Self::Item: Clone;

    fn copy_from_slice(&mut self, src: &[Self::Item])
    where
        Self::Item: Copy;

    fn swap_with_slice(&mut self, src: &mut [Self::Item]);

    fn sort_unstable(&mut self)
    where
        Self::Item: Ord;

    fn sort_unstable_by<F>(&mut self, compare: F)
    where
        F: FnMut(&Self::Item, &Self::Item) -> Ordering;

    fn sort_unstable_by_key<B, F>(&mut self, f: F)
    where
        F: FnMut(&Self::Item) -> B,
        B: Ord;

    fn is_empty(&self) -> bool { ... }
}
🔬 This is a nightly-only experimental API. (core_slice_ext #32110)

stable interface provided by impl [T] in later crates

Extension methods for slices.

Associated Types

🔬 This is a nightly-only experimental API. (core_slice_ext #32110)

stable interface provided by impl [T] in later crates

Required Methods

ⓘImportant traits for Iter<'a, T>

ⓘImportant traits for Split<'a, T, P>

ⓘImportant traits for RSplit<'a, T, P>

🔬 This is a nightly-only experimental API. (slice_rsplit #41020)
ⓘImportant traits for SplitN<'a, T, P>

ⓘImportant traits for RSplitN<'a, T, P>

ⓘImportant traits for Windows<'a, T>

ⓘImportant traits for Chunks<'a, T>

ⓘImportant traits for IterMut<'a, T>

ⓘImportant traits for SplitMut<'a, T, P>

ⓘImportant traits for RSplitMut<'a, T, P>

🔬 This is a nightly-only experimental API. (slice_rsplit #41020)
ⓘImportant traits for SplitNMut<'a, T, P>

ⓘImportant traits for RSplitNMut<'a, T, P>

ⓘImportant traits for ChunksMut<'a, T>

🔬 This is a nightly-only experimental API. (slice_rotate #41891)

🔬 This is a nightly-only experimental API. (swap_with_slice #44030)

Provided Methods

Implementors