bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

doc: Use vec![] instead of vec!() in Vec.

Browse source
This commit is contained in:
Jonas Hietala 2014-07-22 10:33:26 +02:00
parent 6e3e0a83aa
commit c004bebc9e
1 changed files with 77 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

154
src/libcollections/vec.rs
View file

@ -151,7 +151,7 @@ impl<T> Vec<T> {
/// ```rust /// ```rust
/// # use std::vec::Vec; /// # use std::vec::Vec;
/// let vec = Vec::from_fn(3, |idx| idx * 2); /// let vec = Vec::from_fn(3, |idx| idx * 2);
/// assert_eq!(vec, vec!(0, 2, 4)); /// assert_eq!(vec, vec![0, 2, 4]);
/// ``` /// ```
#[inline] #[inline]
pub fn from_fn(length: uint, op: |uint| -> T) -> Vec<T> { pub fn from_fn(length: uint, op: |uint| -> T) -> Vec<T> {
@ -189,10 +189,10 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2i, 3i, 4i); /// let vec = vec![1i, 2i, 3i, 4i];
/// let (even, odd) = vec.partition(|&n| n % 2 == 0); /// let (even, odd) = vec.partition(|&n| n % 2 == 0);
/// assert_eq!(even, vec!(2, 4)); /// assert_eq!(even, vec![2, 4]);
/// assert_eq!(odd, vec!(1, 3)); /// assert_eq!(odd, vec![1, 3]);
/// ``` /// ```
#[inline] #[inline]
pub fn partition(self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) { pub fn partition(self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) {
@ -218,9 +218,9 @@ impl<T: Clone> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2i); /// let vec = vec![1i, 2i];
/// let vec = vec.append([3i, 4i]); /// let vec = vec.append([3i, 4i]);
/// assert_eq!(vec, vec!(1, 2, 3, 4)); /// assert_eq!(vec, vec![1, 2, 3, 4]);
/// ``` /// ```
#[inline] #[inline]
pub fn append(mut self, second: &[T]) -> Vec<T> { pub fn append(mut self, second: &[T]) -> Vec<T> {
@ -276,9 +276,9 @@ impl<T: Clone> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i); /// let mut vec = vec![1i];
/// vec.push_all([2i, 3, 4]); /// vec.push_all([2i, 3, 4]);
/// assert_eq!(vec, vec!(1, 2, 3, 4)); /// assert_eq!(vec, vec![1, 2, 3, 4]);
/// ``` /// ```
#[inline] #[inline]
pub fn push_all(&mut self, other: &[T]) { pub fn push_all(&mut self, other: &[T]) {
@ -306,9 +306,9 @@ impl<T: Clone> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!("hello"); /// let mut vec = vec!["hello"];
/// vec.grow(2, &("world")); /// vec.grow(2, &("world"));
/// assert_eq!(vec, vec!("hello", "world", "world")); /// assert_eq!(vec, vec!["hello", "world", "world"]);
/// ``` /// ```
pub fn grow(&mut self, n: uint, value: &T) { pub fn grow(&mut self, n: uint, value: &T) {
self.reserve_additional(n); self.reserve_additional(n);
@ -330,10 +330,10 @@ impl<T: Clone> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!("a", "b", "c"); /// let mut vec = vec!["a", "b", "c"];
/// vec.grow_set(1, &("fill"), "d"); /// vec.grow_set(1, &("fill"), "d");
/// vec.grow_set(4, &("fill"), "e"); /// vec.grow_set(4, &("fill"), "e");
/// assert_eq!(vec, vec!("a", "d", "c", "fill", "e")); /// assert_eq!(vec, vec!["a", "d", "c", "fill", "e"]);
/// ``` /// ```
pub fn grow_set(&mut self, index: uint, initval: &T, value: T) { pub fn grow_set(&mut self, index: uint, initval: &T, value: T) {
let l = self.len(); let l = self.len();
@ -352,10 +352,10 @@ impl<T: Clone> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3, 4); /// let vec = vec![1i, 2, 3, 4];
/// let (even, odd) = vec.partitioned(|&n| n % 2 == 0); /// let (even, odd) = vec.partitioned(|&n| n % 2 == 0);
/// assert_eq!(even, vec!(2i, 4)); /// assert_eq!(even, vec![2i, 4]);
/// assert_eq!(odd, vec!(1i, 3)); /// assert_eq!(odd, vec![1i, 3]);
/// ``` /// ```
pub fn partitioned(&self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) { pub fn partitioned(&self, f: |&T| -> bool) -> (Vec<T>, Vec<T>) {
let mut lefts = Vec::new(); let mut lefts = Vec::new();
@ -522,7 +522,7 @@ impl<T> Vec<T> {
/// ///
/// ```rust /// ```rust
/// # use std::vec::Vec; /// # use std::vec::Vec;
/// let mut vec: Vec<int> = vec!(1i); /// let mut vec: Vec<int> = vec![1i];
/// vec.reserve_additional(10); /// vec.reserve_additional(10);
/// assert!(vec.capacity() >= 11); /// assert!(vec.capacity() >= 11);
/// ``` /// ```
@ -547,7 +547,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// vec.reserve(10); /// vec.reserve(10);
/// assert!(vec.capacity() >= 10); /// assert!(vec.capacity() >= 10);
/// ``` /// ```
@ -589,7 +589,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// vec.shrink_to_fit(); /// vec.shrink_to_fit();
/// ``` /// ```
pub fn shrink_to_fit(&mut self) { pub fn shrink_to_fit(&mut self) {
@ -621,9 +621,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// assert_eq!(vec.pop(), Some(3)); /// assert_eq!(vec.pop(), Some(3));
/// assert_eq!(vec, vec!(1, 2)); /// assert_eq!(vec, vec![1, 2]);
/// ``` /// ```
#[inline] #[inline]
pub fn pop(&mut self) -> Option<T> { pub fn pop(&mut self) -> Option<T> {
@ -646,9 +646,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2); /// let mut vec = vec![1i, 2];
/// vec.push(3); /// vec.push(3);
/// assert_eq!(vec, vec!(1, 2, 3)); /// assert_eq!(vec, vec![1, 2, 3]);
/// ``` /// ```
#[inline] #[inline]
pub fn push(&mut self, value: T) { pub fn push(&mut self, value: T) {
@ -682,9 +682,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2); /// let vec = vec![1i, 2];
/// let vec = vec.append_one(3); /// let vec = vec.append_one(3);
/// assert_eq!(vec, vec!(1, 2, 3)); /// assert_eq!(vec, vec![1, 2, 3]);
/// ``` /// ```
#[inline] #[inline]
pub fn append_one(mut self, x: T) -> Vec<T> { pub fn append_one(mut self, x: T) -> Vec<T> {
@ -700,9 +700,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3, 4); /// let mut vec = vec![1i, 2, 3, 4];
/// vec.truncate(2); /// vec.truncate(2);
/// assert_eq!(vec, vec!(1, 2)); /// assert_eq!(vec, vec![1, 2]);
/// ``` /// ```
pub fn truncate(&mut self, len: uint) { pub fn truncate(&mut self, len: uint) {
unsafe { unsafe {
@ -723,7 +723,7 @@ impl<T> Vec<T> {
/// ```rust /// ```rust
/// fn foo(slice: &mut [int]) {} /// fn foo(slice: &mut [int]) {}
/// ///
/// let mut vec = vec!(1i, 2); /// let mut vec = vec![1i, 2];
/// foo(vec.as_mut_slice()); /// foo(vec.as_mut_slice());
/// ``` /// ```
#[inline] #[inline]
@ -743,7 +743,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let v = vec!("a".to_string(), "b".to_string()); /// let v = vec!["a".to_string(), "b".to_string()];
/// for s in v.move_iter() { /// for s in v.move_iter() {
/// // s has type String, not &String /// // s has type String, not &String
/// println!("{}", s); /// println!("{}", s);
@ -782,7 +782,7 @@ impl<T> Vec<T> {
/// ```rust /// ```rust
/// #![allow(deprecated)] /// #![allow(deprecated)]
/// ///
/// let vec = vec!(1i, 2, 3); /// let vec = vec![1i, 2, 3];
/// assert!(vec.get(1) == &2); /// assert!(vec.get(1) == &2);
/// ``` /// ```
#[deprecated="prefer using indexing, e.g., vec[0]"] #[deprecated="prefer using indexing, e.g., vec[0]"]
@ -800,9 +800,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// *vec.get_mut(1) = 4; /// *vec.get_mut(1) = 4;
/// assert_eq!(vec, vec!(1i, 4, 3)); /// assert_eq!(vec, vec![1i, 4, 3]);
/// ``` /// ```
#[inline] #[inline]
pub fn get_mut<'a>(&'a mut self, index: uint) -> &'a mut T { pub fn get_mut<'a>(&'a mut self, index: uint) -> &'a mut T {
@ -815,7 +815,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3); /// let vec = vec![1i, 2, 3];
/// for num in vec.iter() { /// for num in vec.iter() {
/// println!("{}", *num); /// println!("{}", *num);
/// } /// }
@ -832,7 +832,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// for num in vec.mut_iter() { /// for num in vec.mut_iter() {
/// *num = 0; /// *num = 0;
/// } /// }
@ -850,13 +850,13 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut v = vec!(5i, 4, 1, 3, 2); /// let mut v = vec![5i, 4, 1, 3, 2];
/// v.sort_by(|a, b| a.cmp(b)); /// v.sort_by(|a, b| a.cmp(b));
/// assert_eq!(v, vec!(1i, 2, 3, 4, 5)); /// assert_eq!(v, vec![1i, 2, 3, 4, 5]);
/// ///
/// // reverse sorting /// // reverse sorting
/// v.sort_by(|a, b| b.cmp(a)); /// v.sort_by(|a, b| b.cmp(a));
/// assert_eq!(v, vec!(5i, 4, 3, 2, 1)); /// assert_eq!(v, vec![5i, 4, 3, 2, 1]);
/// ``` /// ```
#[inline] #[inline]
pub fn sort_by(&mut self, compare: |&T, &T| -> Ordering) { pub fn sort_by(&mut self, compare: |&T, &T| -> Ordering) {
@ -873,7 +873,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3, 4); /// let vec = vec![1i, 2, 3, 4];
/// assert!(vec.slice(0, 2) == [1, 2]); /// assert!(vec.slice(0, 2) == [1, 2]);
/// ``` /// ```
#[inline] #[inline]
@ -890,7 +890,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3); /// let vec = vec![1i, 2, 3];
/// assert!(vec.tail() == [2, 3]); /// assert!(vec.tail() == [2, 3]);
/// ``` /// ```
#[inline] #[inline]
@ -907,7 +907,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3, 4); /// let vec = vec![1i, 2, 3, 4];
/// assert!(vec.tailn(2) == [3, 4]); /// assert!(vec.tailn(2) == [3, 4]);
/// ``` /// ```
#[inline] #[inline]
@ -921,7 +921,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3); /// let vec = vec![1i, 2, 3];
/// assert!(vec.last() == Some(&3)); /// assert!(vec.last() == Some(&3));
/// ``` /// ```
#[inline] #[inline]
@ -935,9 +935,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// *vec.mut_last().unwrap() = 4; /// *vec.mut_last().unwrap() = 4;
/// assert_eq!(vec, vec!(1i, 2, 4)); /// assert_eq!(vec, vec![1i, 2, 4]);
/// ``` /// ```
#[inline] #[inline]
pub fn mut_last<'a>(&'a mut self) -> Option<&'a mut T> { pub fn mut_last<'a>(&'a mut self) -> Option<&'a mut T> {
@ -951,14 +951,14 @@ impl<T> Vec<T> {
/// ///
/// # Example /// # Example
/// ```rust /// ```rust
/// let mut v = vec!("foo".to_string(), "bar".to_string(), /// let mut v = vec!["foo".to_string(), "bar".to_string(),
/// "baz".to_string(), "qux".to_string()); /// "baz".to_string(), "qux".to_string()];
/// ///
/// assert_eq!(v.swap_remove(1), Some("bar".to_string())); /// assert_eq!(v.swap_remove(1), Some("bar".to_string()));
/// assert_eq!(v, vec!("foo".to_string(), "qux".to_string(), "baz".to_string())); /// assert_eq!(v, vec!["foo".to_string(), "qux".to_string(), "baz".to_string()]);
/// ///
/// assert_eq!(v.swap_remove(0), Some("foo".to_string())); /// assert_eq!(v.swap_remove(0), Some("foo".to_string()));
/// assert_eq!(v, vec!("baz".to_string(), "qux".to_string())); /// assert_eq!(v, vec!["baz".to_string(), "qux".to_string()]);
/// ///
/// assert_eq!(v.swap_remove(2), None); /// assert_eq!(v.swap_remove(2), None);
/// ``` /// ```
@ -983,9 +983,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// vec.unshift(4); /// vec.unshift(4);
/// assert_eq!(vec, vec!(4, 1, 2, 3)); /// assert_eq!(vec, vec![4, 1, 2, 3]);
/// ``` /// ```
#[inline] #[inline]
pub fn unshift(&mut self, element: T) { pub fn unshift(&mut self, element: T) {
@ -1003,9 +1003,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// assert!(vec.shift() == Some(1)); /// assert!(vec.shift() == Some(1));
/// assert_eq!(vec, vec!(2, 3)); /// assert_eq!(vec, vec![2, 3]);
/// ``` /// ```
#[inline] #[inline]
pub fn shift(&mut self) -> Option<T> { pub fn shift(&mut self) -> Option<T> {
@ -1023,11 +1023,11 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3); /// let mut vec = vec![1i, 2, 3];
/// vec.insert(1, 4); /// vec.insert(1, 4);
/// assert_eq!(vec, vec!(1, 4, 2, 3)); /// assert_eq!(vec, vec![1, 4, 2, 3]);
/// vec.insert(4, 5); /// vec.insert(4, 5);
/// assert_eq!(vec, vec!(1, 4, 2, 3, 5)); /// assert_eq!(vec, vec![1, 4, 2, 3, 5]);
/// ``` /// ```
pub fn insert(&mut self, index: uint, element: T) { pub fn insert(&mut self, index: uint, element: T) {
let len = self.len(); let len = self.len();
@ -1057,13 +1057,13 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut v = vec!(1i, 2, 3); /// let mut v = vec![1i, 2, 3];
/// assert_eq!(v.remove(1), Some(2)); /// assert_eq!(v.remove(1), Some(2));
/// assert_eq!(v, vec!(1, 3)); /// assert_eq!(v, vec![1, 3]);
/// ///
/// assert_eq!(v.remove(4), None); /// assert_eq!(v.remove(4), None);
/// // v is unchanged: /// // v is unchanged:
/// assert_eq!(v, vec!(1, 3)); /// assert_eq!(v, vec![1, 3]);
/// ``` /// ```
pub fn remove(&mut self, index: uint) -> Option<T> { pub fn remove(&mut self, index: uint) -> Option<T> {
let len = self.len(); let len = self.len();
@ -1096,9 +1096,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(box 1i); /// let mut vec = vec![box 1i];
/// vec.push_all_move(vec!(box 2, box 3, box 4)); /// vec.push_all_move(vec![box 2, box 3, box 4]);
/// assert_eq!(vec, vec!(box 1, box 2, box 3, box 4)); /// assert_eq!(vec, vec![box 1, box 2, box 3, box 4]);
/// ``` /// ```
#[inline] #[inline]
pub fn push_all_move(&mut self, other: Vec<T>) { pub fn push_all_move(&mut self, other: Vec<T>) {
@ -1115,7 +1115,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3, 4); /// let mut vec = vec![1i, 2, 3, 4];
/// assert!(vec.mut_slice(0, 2) == [1, 2]); /// assert!(vec.mut_slice(0, 2) == [1, 2]);
/// ``` /// ```
#[inline] #[inline]
@ -1133,7 +1133,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3, 4); /// let mut vec = vec![1i, 2, 3, 4];
/// assert!(vec.mut_slice_from(2) == [3, 4]); /// assert!(vec.mut_slice_from(2) == [3, 4]);
/// ``` /// ```
#[inline] #[inline]
@ -1150,7 +1150,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3, 4); /// let mut vec = vec![1i, 2, 3, 4];
/// assert!(vec.mut_slice_to(2) == [1, 2]); /// assert!(vec.mut_slice_to(2) == [1, 2]);
/// ``` /// ```
#[inline] #[inline]
@ -1171,7 +1171,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3, 4, 5, 6); /// let mut vec = vec![1i, 2, 3, 4, 5, 6];
/// ///
/// // scoped to restrict the lifetime of the borrows /// // scoped to restrict the lifetime of the borrows
/// { /// {
@ -1202,9 +1202,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut v = vec!(1i, 2, 3); /// let mut v = vec![1i, 2, 3];
/// v.reverse(); /// v.reverse();
/// assert_eq!(v, vec!(3i, 2, 1)); /// assert_eq!(v, vec![3i, 2, 1]);
/// ``` /// ```
#[inline] #[inline]
pub fn reverse(&mut self) { pub fn reverse(&mut self) {
@ -1220,7 +1220,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3); /// let vec = vec![1i, 2, 3];
/// assert!(vec.slice_from(1) == [2, 3]); /// assert!(vec.slice_from(1) == [2, 3]);
/// ``` /// ```
#[inline] #[inline]
@ -1237,7 +1237,7 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3); /// let vec = vec![1i, 2, 3];
/// assert!(vec.slice_to(2) == [1, 2]); /// assert!(vec.slice_to(2) == [1, 2]);
/// ``` /// ```
#[inline] #[inline]
@ -1288,9 +1288,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 3, 4); /// let mut vec = vec![1i, 2, 3, 4];
/// vec.retain(|x| x%2 == 0); /// vec.retain(|x| x%2 == 0);
/// assert_eq!(vec, vec!(2, 4)); /// assert_eq!(vec, vec![2, 4]);
/// ``` /// ```
pub fn retain(&mut self, f: |&T| -> bool) { pub fn retain(&mut self, f: |&T| -> bool) {
let len = self.len(); let len = self.len();
@ -1319,9 +1319,9 @@ impl<T> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(0u, 1); /// let mut vec = vec![0u, 1];
/// vec.grow_fn(3, |i| i); /// vec.grow_fn(3, |i| i);
/// assert_eq!(vec, vec!(0, 1, 0, 1, 2)); /// assert_eq!(vec, vec![0, 1, 0, 1, 2]);
/// ``` /// ```
pub fn grow_fn(&mut self, n: uint, f: |uint| -> T) { pub fn grow_fn(&mut self, n: uint, f: |uint| -> T) {
self.reserve_additional(n); self.reserve_additional(n);
@ -1340,9 +1340,9 @@ impl<T:Ord> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(3i, 1, 2); /// let mut vec = vec![3i, 1, 2];
/// vec.sort(); /// vec.sort();
/// assert_eq!(vec, vec!(1, 2, 3)); /// assert_eq!(vec, vec![1, 2, 3]);
/// ``` /// ```
pub fn sort(&mut self) { pub fn sort(&mut self) {
self.as_mut_slice().sort() self.as_mut_slice().sort()
@ -1362,7 +1362,7 @@ impl<T:PartialEq> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let vec = vec!(1i, 2, 3); /// let vec = vec![1i, 2, 3];
/// assert!(vec.contains(&1)); /// assert!(vec.contains(&1));
/// ``` /// ```
#[inline] #[inline]
@ -1377,9 +1377,9 @@ impl<T:PartialEq> Vec<T> {
/// # Example /// # Example
/// ///
/// ```rust /// ```rust
/// let mut vec = vec!(1i, 2, 2, 3, 2); /// let mut vec = vec![1i, 2, 2, 3, 2];
/// vec.dedup(); /// vec.dedup();
/// assert_eq!(vec, vec!(1i, 2, 3, 2)); /// assert_eq!(vec, vec![1i, 2, 3, 2]);
/// ``` /// ```
pub fn dedup(&mut self) { pub fn dedup(&mut self) {
unsafe { unsafe {
@ -1474,7 +1474,7 @@ impl<T> Vector<T> for Vec<T> {
/// ```rust /// ```rust
/// fn foo(slice: &[int]) {} /// fn foo(slice: &[int]) {}
/// ///
/// let vec = vec!(1i, 2); /// let vec = vec![1i, 2];
/// foo(vec.as_slice()); /// foo(vec.as_slice());
/// ``` /// ```
#[inline] #[inline]