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). |