Module std::slice
[−]
[src]
Utilities for slice manipulation
The slice`slice` module contains useful code to help work with slice values.
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]`&[T], while the mutable slice type is`,
while the mutable slice type is &mut [T]`&mut [T], where`, where T`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`Iter`, which
represents iteration over a slice.
Trait Implementations
There are several implementations of common traits for slices. Some examples include:
Clone`Clone`Eq`Eq,`,Ord`Ord- for slices whose element type are` - for slices whose element type areEq`Eqor` orOrd`Ord`.Hash`Hash- for slices whose element type is` - for slices whose element type isHash`Hash`
Iteration
The slices implement IntoIterator`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:
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`i32, the element type of the iterator is`, the element type of the iterator is &mut i32`&mut i32`.
.iter()`.iter()and` and.iter_mut()`.iter_mut()` are the explicit methods to return the default iterators.- Further methods that return iterators are
.split()`.split(),`,.splitn()`.splitn(),`,.chunks()`.chunks(),`,.windows()`.windows()` and more.
Modules
| bytes |
[Unstable] Operations on |
Structs
| Chunks |
An iterator over a slice in (non-overlapping) chunks ( |
| ChunksMut |
An iterator over a slice in (non-overlapping) mutable chunks ( |
| 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 |
| 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 |
| ElementSwaps |
[Unstable] An iterator that yields the element swaps needed to produce a sequence of all possible permutations for an indexed sequence of elements. Each permutation is only a single swap apart. |
| Permutations |
[Unstable] An iterator that uses |
Traits
| IntSliceExt |
[Unstable] Extension methods for slices containing integers. |
| 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 |
| mut_ref_slice |
[Unstable] Converts a pointer to A into a slice of length 1 (without copying). |
| ref_slice |
[Unstable] Converts a pointer to A into a slice of length 1 (without copying). |