Module collections::sliceExperimental

Utilities for slice manipulation

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

fn main() { // slicing a Vec let vec = vec!(1i, 2, 3); let int_slice = vec.as_slice(); // coercing an array to a slice let str_slice: &[&str] = &["one", "two", "three"]; }

// slicing a Vec
let vec = vec!(1i, 2, 3);
let int_slice = vec.as_slice();
// 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]. For example, you can mutate the block of memory that a mutable slice points to:

fn main() { let x: &mut[int] = &mut [1i, 2, 3]; x[1] = 7; assert_eq!(x[0], 1); assert_eq!(x[1], 7); assert_eq!(x[2], 3); }

let x: &mut[int] = &mut [1i, 2, 3];
x[1] = 7;
assert_eq!(x[0], 1);
assert_eq!(x[1], 7);
assert_eq!(x[2], 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.

Traits

A number of traits add methods that allow you to accomplish tasks with slices, the most important being SliceExt. Other traits apply only to slices of elements satisfying certain bounds (like Ord).

An example is the slice method which enables slicing syntax [a..b] that returns an immutable "view" into a Vec or another slice from the index interval [a, b):

#![feature(slicing_syntax)] fn main() { let numbers = [0i, 1i, 2i]; let last_numbers = numbers[1..3]; // last_numbers is now &[1i, 2i] }

#![feature(slicing_syntax)]
fn main() {
    let numbers = [0i, 1i, 2i];
    let last_numbers = numbers[1..3];
    // last_numbers is now &[1i, 2i]
}

Implementations of other traits

There are several implementations of common traits for slices. Some examples include:

• Clone
• Eq, Ord - for immutable slices whose element type are Eq or Ord.
• Hash - for slices whose element type is Hash

Iteration

The method iter() returns an iteration value for a slice. The iterator yields references to the slice's elements, so if the element type of the slice is int, the element type of the iterator is &int.

fn main() { let numbers = [0i, 1i, 2i]; for &x in numbers.iter() { println!("{} is a number!", x); } }

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

• .iter_mut() returns an iterator that allows modifying each value.
• Further iterators exist that split, chunk or permute the slice.

Modules

bytes	Operations on [u8].
raw	Deprecated, unsafe operations

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.
ElementSwaps	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.
Iter	Immutable slice iterator
IterMut	Mutable slice iterator.
Permutations	An iterator that uses ElementSwaps to iterate through all possible permutations of a vector.
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

AsSlice	Data that is viewable as a slice.
BoxedSliceExt	Extension methods for boxed slices.
CloneSliceExt	Allocating extension methods for slices containing Clone elements.
IntSliceExt	Extension methods for slices containing integers.
OrdSliceExt	Allocating extension methods for slices on Ord values.
PartialEqSliceExt	Extension methods for slices containing PartialEq elements.
SliceConcatExt	An extension trait for concatenating slices
SliceExt	Allocating extension methods for slices.

Functions

from_raw_buf	Forms a slice from a pointer and a length.
from_raw_mut_buf	Performs the same functionality as from_raw_buf, except that a mutable slice is returned.
mut_ref_slice	Converts a pointer to A into a slice of length 1 (without copying).
ref_slice	Converts a pointer to A into a slice of length 1 (without copying).

Type Definitions

Items
MutItems