Module collections::slice [−] [src]

A dynamically-sized view into a contiguous sequence, [T].

Slices are a view into a block of memory represented as a pointer and a length.

fn main() { // slicing a Vec let vec = vec![1, 2, 3]; let int_slice = &vec[..]; // coercing an array to a slice let str_slice: &[&str] = &["one", "two", "three"]; }

// slicing a Vec
let vec = vec![1, 2, 3];
let int_slice = &vec[..];
// coercing an array to a slice
let str_slice: &[&str] = &["one", "two", "three"];

Slices are either mutable or shared. The shared slice type is &[T], while the mutable slice type is &mut [T], where T represents the element type. For example, you can mutate the block of memory that a mutable slice points to:

fn main() { let x = &mut [1, 2, 3]; x[1] = 7; assert_eq!(x, &[1, 7, 3]); }

let x = &mut [1, 2, 3];
x[1] = 7;
assert_eq!(x, &[1, 7, 3]);

Here are some of the things this module contains:

Structs

There are several structs that are useful for slices, such as Iter, which represents iteration over a slice.

Trait Implementations

There are several implementations of common traits for slices. Some examples include:

Clone
Eq, Ord - for slices whose element type are Eq or Ord.
Hash - for slices whose element type is Hash

Iteration

The slices implement IntoIterator. The iterator yields references to the slice elements.

fn main() { let numbers = &[0, 1, 2]; for n in numbers { println!("{} is a number!", n); } }

let numbers = &[0, 1, 2];
for n in numbers {
    println!("{} is a number!", n);
}

The mutable slice yields mutable references to the elements:

fn main() { let mut scores = [7, 8, 9]; for score in &mut scores[..] { *score += 1; } }

let mut scores = [7, 8, 9];
for score in &mut scores[..] {
    *score += 1;
}

This iterator yields mutable references to the slice's elements, so while the element type of the slice is i32, the element type of the iterator is &mut i32.

.iter() and .iter_mut() are the explicit methods to return the default iterators.
Further methods that return iterators are .split(), .splitn(), .chunks(), .windows() and more.

See also the slice primitive type.

Reexports

use core::prelude::v1::*;

use alloc::boxed::Box;

use core::cmp::Ordering::{self, Greater, Less};

use core::cmp;

use core::mem::size_of;

use core::mem;

use core::ptr;

use core::slice as core_slice;

use borrow::{Borrow, BorrowMut, ToOwned};

use vec::Vec;

Modules

bytes	[Deprecated] Operations on `[u8]`.
hack

Structs

Chunks	An iterator over a slice in (non-overlapping) chunks (`size` elements at a time).
ChunksMut	An iterator over a slice in (non-overlapping) mutable chunks (`size` elements at a time). When the slice len is not evenly divided by the chunk size, the last slice of the iteration will be the remainder.
Iter	Immutable slice iterator
IterMut	Mutable slice iterator.
RSplitN	An iterator over subslices separated by elements that match a predicate function, limited to a given number of splits, starting from the end of the slice.
RSplitNMut	An iterator over subslices separated by elements that match a predicate function, limited to a given number of splits, starting from the end of the slice.
Split	An iterator over subslices separated by elements that match a predicate function.
SplitMut	An iterator over the subslices of the vector which are separated by elements that match `pred`.
SplitN	An iterator over subslices separated by elements that match a predicate function, limited to a given number of splits.
SplitNMut	An iterator over subslices separated by elements that match a predicate function, limited to a given number of splits.
Windows	An iterator over overlapping subslices of length `size`.

Traits

SliceConcatExt

[Unstable]

An extension trait for concatenating slices

Functions

from_raw_parts	Forms a slice from a pointer and a length.
from_raw_parts_mut	Performs the same functionality as `from_raw_parts`, except that a mutable slice is returned.
insertion_sort
merge_sort