+
Returns the number of elements the vector can hold without
+reallocating.
+
+
+let vec: Vec<i32> = Vec::with_capacity(10);
+assert_eq!(vec.capacity(), 10);
+
+
fn reserve(&mut self, additional: usize)
+
Reserves capacity for at least additional more elements to be inserted
+in the given Vec<T>. The collection may reserve more space to avoid
+frequent reallocations.
+
+
+
Panics if the new capacity overflows usize.
+
+
+let mut vec = vec![1];
+vec.reserve(10);
+assert!(vec.capacity() >= 11);
+
+
+
Reserves the minimum capacity for exactly additional more elements to
+be inserted in the given Vec<T>. Does nothing if the capacity is already
+sufficient.
+
+
Note that the allocator may give the collection more space than it
+requests. Therefore capacity can not be relied upon to be precisely
+minimal. Prefer reserve if future insertions are expected.
+
+
+
Panics if the new capacity overflows usize.
+
+
+let mut vec = vec![1];
+vec.reserve_exact(10);
+assert!(vec.capacity() >= 11);
+
+
+
Shrinks the capacity of the vector as much as possible.
+
+
It will drop down as close as possible to the length but the allocator
+may still inform the vector that there is space for a few more elements.
+
+
+let mut vec = Vec::with_capacity(10);
+vec.extend([1, 2, 3].iter().cloned());
+assert_eq!(vec.capacity(), 10);
+vec.shrink_to_fit();
+assert!(vec.capacity() >= 3);
+
+
+
Converts the vector into Box<[T]>.
+
+
Note that this will drop any excess capacity. Calling this and
+converting back to a vector with into_vec() is equivalent to calling
+shrink_to_fit().
+
+
Shorten a vector, dropping excess elements.
+
+
If len is greater than the vector's current length, this has no
+effect.
+
+
+let mut vec = vec![1, 2, 3, 4];
+vec.truncate(2);
+assert_eq!(vec, [1, 2]);
+
+
+
Unstable: waiting on RFC revision
+ Extracts a slice containing the entire vector.
+
+
Equivalent to &s[..].
+
+
Unstable: waiting on RFC revision
+ Extracts a mutable slice of the entire vector.
+
+
Equivalent to &mut s[..].
+
unsafe fn set_len(&mut self, len: usize)
+
Sets the length of a vector.
+
+
This will explicitly set the size of the vector, without actually
+modifying its buffers, so it is up to the caller to ensure that the
+vector is actually the specified size.
+
+
+let mut v = vec![1, 2, 3, 4];
+unsafe {
+ v.set_len(1);
+}
+
+
+
Removes an element from anywhere in the vector and return it, replacing
+it with the last element.
+
+
This does not preserve ordering, but is O(1).
+
+
+
Panics if index is out of bounds.
+
+
+let mut v = vec!["foo", "bar", "baz", "qux"];
+
+assert_eq!(v.swap_remove(1), "bar");
+assert_eq!(v, ["foo", "qux", "baz"]);
+
+assert_eq!(v.swap_remove(0), "foo");
+assert_eq!(v, ["baz", "qux"]);
+
+
fn insert(&mut self, index: usize, element: T)
+
Inserts an element at position index within the vector, shifting all
+elements after position i one position to the right.
+
+
+
Panics if index is greater than the vector's length.
+
+
+let mut vec = vec![1, 2, 3];
+vec.insert(1, 4);
+assert_eq!(vec, [1, 4, 2, 3]);
+vec.insert(4, 5);
+assert_eq!(vec, [1, 4, 2, 3, 5]);
+
+
fn remove(&mut self, index: usize) -> T
+
Removes and returns the element at position index within the vector,
+shifting all elements after position index one position to the left.
+
+
+
Panics if index is out of bounds.
+
+
+let mut v = vec![1, 2, 3];
+assert_eq!(v.remove(1), 2);
+assert_eq!(v, [1, 3]);
+
+
fn retain<F>(&mut self, f: F) where F: FnMut(&T) -> bool
+
Retains only the elements specified by the predicate.
+
+
In other words, remove all elements e such that f(&e) returns false.
+This method operates in place and preserves the order of the retained
+elements.
+
+
+let mut vec = vec![1, 2, 3, 4];
+vec.retain(|&x| x%2 == 0);
+assert_eq!(vec, [2, 4]);
+
+
fn push(&mut self, value: T)
+
Appends an element to the back of a collection.
+
+
+
Panics if the number of elements in the vector overflows a usize.
+
+
+let mut vec = vec!(1, 2);
+vec.push(3);
+assert_eq!(vec, [1, 2, 3]);
+
+
fn pop(&mut self) -> Option<T>
+
Removes the last element from a vector and returns it, or None if it is empty.
+
+
+let mut vec = vec![1, 2, 3];
+assert_eq!(vec.pop(), Some(3));
+assert_eq!(vec, [1, 2]);
+
+
fn append(&mut self, other: &mut Vec<T>)
+
Unstable: new API, waiting for dust to settle
+ Moves all the elements of other into Self, leaving other empty.
+
+
+
Panics if the number of elements in the vector overflows a usize.
+
+
+let mut vec = vec![1, 2, 3];
+let mut vec2 = vec![4, 5, 6];
+vec.append(&mut vec2);
+assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
+assert_eq!(vec2, []);
+
+
+
Unstable: recently added, matches RFC
+ Create a draining iterator that removes the specified range in the vector
+and yields the removed items from start to end. The element range is
+removed even if the iterator is not consumed until the end.
+
+
Note: It is unspecified how many elements are removed from the vector,
+if the Drain value is leaked.
+
+
+
Panics if the starting point is greater than the end point or if
+the end point is greater than the length of the vector.
+
+
+
+
+let mut v = vec![1, 2, 3];
+let u: Vec<_> = v.drain(..).collect();
+assert_eq!(v, &[]);
+assert_eq!(u, &[1, 2, 3]);
+
+
fn clear(&mut self)
+
Clears the vector, removing all values.
+
+
+let mut v = vec![1, 2, 3];
+
+v.clear();
+
+assert!(v.is_empty());
+
+
+
Returns the number of elements in the vector.
+
+
+let a = vec![1, 2, 3];
+assert_eq!(a.len(), 3);
+
+
+
Returns true if the vector contains no elements.
+
+
+let mut v = Vec::new();
+assert!(v.is_empty());
+
+v.push(1);
+assert!(!v.is_empty());
+
+
fn map_in_place<U, F>(self, f: F) -> Vec<U> where F: FnMut(T) -> U
+
Unstable: API may change to provide stronger guarantees
+ Converts a Vec<T> to a Vec<U> where T and U have the same
+size and in case they are not zero-sized the same minimal alignment.
+
+
+
Panics if T and U have differing sizes or are not zero-sized and
+have differing minimal alignments.
+
+
+let v = vec![0, 1, 2];
+let w = v.map_in_place(|i| i + 3);
+assert_eq!(&w[..], &[3, 4, 5]);
+
+#[derive(PartialEq, Debug)]
+struct Newtype(u8);
+let bytes = vec![0x11, 0x22];
+let newtyped_bytes = bytes.map_in_place(|x| Newtype(x));
+assert_eq!(&newtyped_bytes[..], &[Newtype(0x11), Newtype(0x22)]);
+
+
+
Unstable: new API, waiting for dust to settle
+ Splits the collection into two at the given index.
+
+
Returns a newly allocated Self. self contains elements [0, at),
+and the returned Self contains elements [at, len).
+
+
Note that the capacity of self does not change.
+
+
+
Panics if at > len.
+
+
+let mut vec = vec![1,2,3];
+let vec2 = vec.split_off(1);
+assert_eq!(vec, [1]);
+assert_eq!(vec2, [2, 3]);
+
+