# Module bitflags::__core::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.

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

See also the slice primitive type.

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

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)