Work with self as a mut slice. Primarily intended for getting a &mut [T] from a [T, ..N].

Return a slice that points into another slice.

Returns a slice of self from start to the end of the vec.

Fails when start points outside the bounds of self.

Returns a slice of self from the start of the vec to end.

Fails when end points outside the bounds of self.

Returns an iterator that allows modifying each value

Returns a mutable pointer to the last item in the vector.

Returns a reversed iterator that allows modifying each value

Returns an iterator over the mutable subslices of the vector which are separated by elements that match pred. The matched element is not contained in the subslices.

Returns an iterator over size elements of the vector at a time. The chunks are mutable and do not overlap. If size does not divide the length of the vector, then the last chunk will not have length size.

Failure

Fails if size is 0.

Returns a mutable reference to the first element in this slice and adjusts the slice in place so that it no longer contains that element. O(1).

Equivalent to:

    if self.len() == 0 { return None; }
    let head = &mut self[0];
    *self = self.mut_slice_from(1);
    Some(head)

Returns None if slice is empty

Returns a mutable reference to the last element in this slice and adjusts the slice in place so that it no longer contains that element. O(1).

Equivalent to:

    if self.len() == 0 { return None; }
    let tail = &mut self[self.len() - 1];
    *self = self.mut_slice_to(self.len() - 1);
    Some(tail)

Returns None if slice is empty.

Swaps two elements in a vector.

Fails if a or b are out of bounds.

Arguments

• a - The index of the first element
• b - The index of the second element

Example

let mut v = ["a", "b", "c", "d"];
v.swap(1, 3);
assert!(v == ["a", "d", "c", "b"]);

Divides one &mut into two at an index.

The first will contain all indices from [0, mid) (excluding the index mid itself) and the second will contain all indices from [mid, len) (excluding the index len itself).

Fails if mid > len.

Example

let mut v = [1, 2, 3, 4, 5, 6];

// scoped to restrict the lifetime of the borrows
{
   let (left, right) = v.mut_split_at(0);
   assert!(left == &mut []);
   assert!(right == &mut [1, 2, 3, 4, 5, 6]);
}

{
    let (left, right) = v.mut_split_at(2);
    assert!(left == &mut [1, 2]);
    assert!(right == &mut [3, 4, 5, 6]);
}

{
    let (left, right) = v.mut_split_at(6);
    assert!(left == &mut [1, 2, 3, 4, 5, 6]);
    assert!(right == &mut []);
}

Reverse the order of elements in a vector, in place.

Example

let mut v = [1, 2, 3];
v.reverse();
assert!(v == [3, 2, 1]);

Sort the vector, in place, using compare to compare elements.

This sort is O(n log n) worst-case and stable, but allocates approximately 2 * n, where n is the length of self.

Example

let mut v = [5i, 4, 1, 3, 2];
v.sort_by(|a, b| a.cmp(b));
assert!(v == [1, 2, 3, 4, 5]);

// reverse sorting
v.sort_by(|a, b| b.cmp(a));
assert!(v == [5, 4, 3, 2, 1]);

Consumes src and moves as many elements as it can into self from the range [start,end).

Returns the number of elements copied (the shorter of self.len() and end - start).

Arguments

• src - A mutable vector of T
• start - The index into src to start copying from
• end - The index into str to stop copying from

Returns an unsafe mutable pointer to the element in index

Return an unsafe mutable pointer to the vector's buffer.

The caller must ensure that the vector outlives the pointer this function returns, or else it will end up pointing to garbage.

Modifying the vector may cause its buffer to be reallocated, which would also make any pointers to it invalid.

Unsafely sets the element in index to the value.

This performs no bounds checks, and it is undefined behaviour if index is larger than the length of self. However, it does run the destructor at index. It is equivalent to self[index] = val.

Example

let mut v = ~[~"foo", ~"bar", ~"baz"];

unsafe {
    // `~"baz"` is deallocated.
    v.unsafe_set(2, ~"qux");

    // Out of bounds: could cause a crash, or overwriting
    // other data, or something else.
    // v.unsafe_set(10, ~"oops");
}

Unchecked vector index assignment. Does not drop the old value and hence is only suitable when the vector is newly allocated.

Example

let mut v = [~"foo", ~"bar"];

// memory leak! `~"bar"` is not deallocated.
unsafe { v.init_elem(1, ~"baz"); }

Copies raw bytes from src to self.

This does not run destructors on the overwritten elements, and ignores move semantics. self and src must not overlap. Fails if self is shorter than src.