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

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