# Module alloc::slice
1.0.0[−][src]

Expand description

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

See also the slice primitive type.

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"];

Run

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]);

Run

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);
    }

Run

The mutable slice yields mutable references to the elements:

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

Run

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

ArrayChunks Experimental

An iterator over a slice in (non-overlapping) chunks (`N` elements at a time), starting at the beginning of the slice.

ArrayChunksMut Experimental

An iterator over a slice in (non-overlapping) mutable chunks (`N` elements at a time), starting at the beginning of the slice.

ArrayWindows Experimental

A windowed iterator over a slice in overlapping chunks (`N` elements at a time), starting at the beginning of the slice

EscapeAscii Experimental

An iterator over the escaped version of a byte slice.

GroupBy Experimental

An iterator over slice in (non-overlapping) chunks separated by a predicate.

GroupByMut Experimental

An iterator over slice in (non-overlapping) mutable chunks separated by a predicate.

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.

SplitInclusive

An iterator over subslices separated by elements that match a predicate function. Unlike `Split`, it contains the matched part as a terminator of the subslice.

SplitInclusiveMut

An iterator over the mutable subslices of the vector which are separated by elements that match `pred`. Unlike `SplitMut`, it contains the matched parts in the ends of the subslices.

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

## Traits

Concat Experimental

Helper trait for `[T]::concat`.

Join Experimental

Helper trait for `[T]::join`

SliceIndex

A helper trait used for indexing operations.

## Functions

range Experimental

Performs bounds-checking of a range.

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