W3cubDocs

/Rust

Module std::slice

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.

// 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:

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.

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

The mutable slice yields mutable references to the elements:

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.

Structs

Chunks	An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a time), starting at the beginning of the slice.
ChunksExact	An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a time), starting at the beginning of the slice.
ChunksExactMut	An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size` elements at a time), starting at the beginning of the slice.
ChunksMut	An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size` elements at a time), starting at the beginning of the slice.
Iter	Immutable slice iterator
IterMut	Mutable slice iterator.
RChunks	An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a time), starting at the end of the slice.
RChunksExact	An iterator over a slice in (non-overlapping) chunks (`chunk_size` elements at a time), starting at the end of the slice.
RChunksExactMut	An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size` elements at a time), starting at the end of the slice.
RChunksMut	An iterator over a slice in (non-overlapping) mutable chunks (`chunk_size` elements at a time), starting at the end of the slice.
RSplit	An iterator over subslices separated by elements that match a predicate function, starting from the end of the slice.
RSplitMut	An iterator over the subslices of the vector which are separated by elements that match `pred`, starting from the end of the slice.
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 mutable 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`.
ArrayChunks	Experimental An iterator over a slice in (non-overlapping) chunks (`N` elements at a time), starting at the beginning of the slice.

Traits

SliceIndex	A helper trait used for indexing operations.
Concat	Experimental Helper trait for `[T]::concat`.
Join	Experimental Helper trait for `[T]::join`

Functions

from_mut	Converts a reference to T into a slice of length 1 (without copying).
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.
from_ref	Converts a reference to T into a slice of length 1 (without copying).

© 2010 The Rust Project Developers
Licensed under the Apache License, Version 2.0 or the MIT license, at your option.
https://doc.rust-lang.org/std/slice/index.html