core::slice::SliceExt - Rust
Description: API documentation for the Rust `SliceExt` trait in crate `core`.
Keywords: rust, rustlang, rust-lang, SliceExt

# 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<Q: ?Sized>(&self, x: &Q) -> Result<usize, usize>
        where
            Self::Item: Borrow<Q>,
            Q: 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, Q: ?Sized>(
            &'a self,
            b: &Q,
            f: F
        ) -> Result<usize, usize>
        where
            F: FnMut(&'a Self::Item) -> B,
            B: Borrow<Q>,
            Q: 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 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

### `type Item`

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

stable interface provided by `impl [T]` in later crates

## Required Methods

### `fn split_at(&self, mid: usize) -> (&[Self::Item], &[Self::Item])`
1.6.0

### `fn iter(&self) -> Iter<Self::Item>`
1.6.0

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

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

🔬 This is a nightly-only experimental API. (`slice_rsplit` #41020)

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

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

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

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

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

### `fn first(&self) -> Option<&Self::Item>`
1.6.0

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

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

### `fn last(&self) -> Option<&Self::Item>`
1.6.0

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

### `fn as_ptr(&self) -> *const Self::Item`
1.6.0

### `fn binary_search<Q: ?Sized>(&self, x: &Q) -> Result<usize, usize> where
Self::Item: Borrow<Q>,
Q: Ord,`
1.6.0

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

### `fn binary_search_by_key<'a, B, F, Q: ?Sized>(
&'a self,
b: &Q,
f: F
) -> Result<usize, usize> where
F: FnMut(&'a Self::Item) -> B,
B: Borrow<Q>,
Q: Ord,`
1.10.0

### `fn len(&self) -> usize`
1.6.0

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

### `fn iter_mut(&mut self) -> IterMut<Self::Item>`
1.6.0

### `fn first_mut(&mut self) -> Option<&mut Self::Item>`
1.6.0

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

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

### `fn last_mut(&mut self) -> Option<&mut Self::Item>`
1.6.0

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

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

🔬 This is a nightly-only experimental API. (`slice_rsplit` #41020)

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

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

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

### `fn swap(&mut self, a: usize, b: usize)`
1.6.0

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

### `fn reverse(&mut self)`
1.6.0

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

### `fn as_mut_ptr(&mut self) -> *mut Self::Item`
1.6.0

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

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

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

### `fn rotate(&mut self, mid: usize)`

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

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

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

### `fn sort_unstable(&mut self) where
Self::Item: Ord,`
1.20.0

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

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

## Provided Methods

### `fn is_empty(&self) -> bool`
1.6.0

## Implementors

- `impl<T> SliceExt for [T]`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result
+
  Collapse/expand all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)