rand: remove (almost) all ~[]'s from Vec.

There are a few instances of them in tests which are using functions
from std etc. that still are using ~[].

Author: huonw

src/libflate/lib.rs

@@ -112,7 +112,7 @@ mod tests {
         for _ in range(0, 20) {
             let mut input = ~[];
             for _ in range(0, 2000) {
-                input.push_all(r.choose(words.as_slice()));
+                input.push_all(r.choose(words.as_slice()).as_slice());
             }
             debug!("de/inflate of {} bytes of random word-sequences",
                    input.len());

src/librand/distributions/mod.rs

@@ -91,18 +91,18 @@ pub struct Weighted<T> {
 /// ```rust
 /// use rand::distributions::{Weighted, WeightedChoice, IndependentSample};
 ///
-/// let wc = WeightedChoice::new(~[Weighted { weight: 2, item: 'a' },
-///                                Weighted { weight: 4, item: 'b' },
-///                                Weighted { weight: 1, item: 'c' }]);
+/// let wc = WeightedChoice::new(vec!(Weighted { weight: 2, item: 'a' },
+///                                   Weighted { weight: 4, item: 'b' },
+///                                   Weighted { weight: 1, item: 'c' }));
 /// let mut rng = rand::task_rng();
 /// for _ in range(0, 16) {
 ///      // on average prints 'a' 4 times, 'b' 8 and 'c' twice.
 ///      println!("{}", wc.ind_sample(&mut rng));
 /// }
 /// ```
 pub struct WeightedChoice<T> {
-    pub items: ~[Weighted<T>],
-    pub weight_range: Range<uint>
+    items: Vec<Weighted<T>>,
+    weight_range: Range<uint>
 }
 
 impl<T: Clone> WeightedChoice<T> {
@@ -112,7 +112,7 @@ impl<T: Clone> WeightedChoice<T> {
     /// - `v` is empty
     /// - the total weight is 0
     /// - the total weight is larger than a `uint` can contain.
-    pub fn new(mut items: ~[Weighted<T>]) -> WeightedChoice<T> {
+    pub fn new(mut items: Vec<Weighted<T>>) -> WeightedChoice<T> {
         // strictly speaking, this is subsumed by the total weight == 0 case
         assert!(!items.is_empty(), "WeightedChoice::new called with no items");
 
@@ -153,8 +153,8 @@ impl<T: Clone> IndependentSample<T> for WeightedChoice<T> {
         let sample_weight = self.weight_range.ind_sample(rng);
 
         // short circuit when it's the first item
-        if sample_weight < self.items[0].weight {
-            return self.items[0].item.clone();
+        if sample_weight < self.items.get(0).weight {
+            return self.items.get(0).item.clone();
         }
 
         let mut idx = 0;
@@ -169,7 +169,7 @@ impl<T: Clone> IndependentSample<T> for WeightedChoice<T> {
         // one is exactly the total weight.)
         while modifier > 1 {
             let i = idx + modifier / 2;
-            if self.items[i].weight <= sample_weight {
+            if self.items.get(i).weight <= sample_weight {
                 // we're small, so look to the right, but allow this
                 // exact element still.
                 idx = i;
@@ -182,7 +182,7 @@ impl<T: Clone> IndependentSample<T> for WeightedChoice<T> {
             }
             modifier /= 2;
         }
-        return self.items[idx + 1].item.clone();
+        return self.items.get(idx + 1).item.clone();
     }
 }
 
@@ -297,54 +297,54 @@ mod tests {
             }}
         );
 
-        t!(~[Weighted { weight: 1, item: 10}], ~[10]);
+        t!(vec!(Weighted { weight: 1, item: 10}), [10]);
 
         // skip some
-        t!(~[Weighted { weight: 0, item: 20},
-             Weighted { weight: 2, item: 21},
-             Weighted { weight: 0, item: 22},
-             Weighted { weight: 1, item: 23}],
-           ~[21,21, 23]);
+        t!(vec!(Weighted { weight: 0, item: 20},
+                Weighted { weight: 2, item: 21},
+                Weighted { weight: 0, item: 22},
+                Weighted { weight: 1, item: 23}),
+           [21,21, 23]);
 
         // different weights
-        t!(~[Weighted { weight: 4, item: 30},
-             Weighted { weight: 3, item: 31}],
-           ~[30,30,30,30, 31,31,31]);
+        t!(vec!(Weighted { weight: 4, item: 30},
+                Weighted { weight: 3, item: 31}),
+           [30,30,30,30, 31,31,31]);
 
         // check that we're binary searching
         // correctly with some vectors of odd
         // length.
-        t!(~[Weighted { weight: 1, item: 40},
-             Weighted { weight: 1, item: 41},
-             Weighted { weight: 1, item: 42},
-             Weighted { weight: 1, item: 43},
-             Weighted { weight: 1, item: 44}],
-           ~[40, 41, 42, 43, 44]);
-        t!(~[Weighted { weight: 1, item: 50},
-             Weighted { weight: 1, item: 51},
-             Weighted { weight: 1, item: 52},
-             Weighted { weight: 1, item: 53},
-             Weighted { weight: 1, item: 54},
-             Weighted { weight: 1, item: 55},
-             Weighted { weight: 1, item: 56}],
-           ~[50, 51, 52, 53, 54, 55, 56]);
+        t!(vec!(Weighted { weight: 1, item: 40},
+                Weighted { weight: 1, item: 41},
+                Weighted { weight: 1, item: 42},
+                Weighted { weight: 1, item: 43},
+                Weighted { weight: 1, item: 44}),
+           [40, 41, 42, 43, 44]);
+        t!(vec!(Weighted { weight: 1, item: 50},
+                Weighted { weight: 1, item: 51},
+                Weighted { weight: 1, item: 52},
+                Weighted { weight: 1, item: 53},
+                Weighted { weight: 1, item: 54},
+                Weighted { weight: 1, item: 55},
+                Weighted { weight: 1, item: 56}),
+           [50, 51, 52, 53, 54, 55, 56]);
     }
 
     #[test] #[should_fail]
     fn test_weighted_choice_no_items() {
-        WeightedChoice::<int>::new(~[]);
+        WeightedChoice::<int>::new(vec!());
     }
     #[test] #[should_fail]
     fn test_weighted_choice_zero_weight() {
-        WeightedChoice::new(~[Weighted { weight: 0, item: 0},
-                              Weighted { weight: 0, item: 1}]);
+        WeightedChoice::new(vec!(Weighted { weight: 0, item: 0},
+                                 Weighted { weight: 0, item: 1}));
     }
     #[test] #[should_fail]
     fn test_weighted_choice_weight_overflows() {
         let x = (-1) as uint / 2; // x + x + 2 is the overflow
-        WeightedChoice::new(~[Weighted { weight: x, item: 0 },
-                              Weighted { weight: 1, item: 1 },
-                              Weighted { weight: x, item: 2 },
-                              Weighted { weight: 1, item: 3 }]);
+        WeightedChoice::new(vec!(Weighted { weight: x, item: 0 },
+                                 Weighted { weight: 1, item: 1 },
+                                 Weighted { weight: x, item: 2 },
+                                 Weighted { weight: 1, item: 3 }));
     }
 }

src/librand/isaac.rs

@@ -441,7 +441,6 @@ impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng {
 mod test {
     use super::{IsaacRng, Isaac64Rng};
     use {Rng, SeedableRng, task_rng};
-    use std::slice;
 
     #[test]
     fn test_rng_32_rand_seeded() {
@@ -479,7 +478,7 @@ mod test {
         let mut r: IsaacRng = SeedableRng::from_seed(s.as_slice());
         let string1 = r.gen_ascii_str(100);
 
-        r.reseed(s);
+        r.reseed(s.as_slice());
 
         let string2 = r.gen_ascii_str(100);
         assert_eq!(string1, string2);
@@ -490,7 +489,7 @@ mod test {
         let mut r: Isaac64Rng = SeedableRng::from_seed(s.as_slice());
         let string1 = r.gen_ascii_str(100);
 
-        r.reseed(s);
+        r.reseed(s.as_slice());
 
         let string2 = r.gen_ascii_str(100);
         assert_eq!(string1, string2);
@@ -501,43 +500,43 @@ mod test {
         let seed = &[1, 23, 456, 7890, 12345];
         let mut ra: IsaacRng = SeedableRng::from_seed(seed);
         // Regression test that isaac is actually using the above vector
-        let v = slice::from_fn(10, |_| ra.next_u32());
+        let v = Vec::from_fn(10, |_| ra.next_u32());
         assert_eq!(v,
-                   ~[2558573138, 873787463, 263499565, 2103644246, 3595684709,
-                     4203127393, 264982119, 2765226902, 2737944514, 3900253796]);
+                   vec!(2558573138, 873787463, 263499565, 2103644246, 3595684709,
+                        4203127393, 264982119, 2765226902, 2737944514, 3900253796));
 
         let seed = &[12345, 67890, 54321, 9876];
         let mut rb: IsaacRng = SeedableRng::from_seed(seed);
         // skip forward to the 10000th number
         for _ in range(0, 10000) { rb.next_u32(); }
 
-        let v = slice::from_fn(10, |_| rb.next_u32());
+        let v = Vec::from_fn(10, |_| rb.next_u32());
         assert_eq!(v,
-                   ~[3676831399, 3183332890, 2834741178, 3854698763, 2717568474,
-                     1576568959, 3507990155, 179069555, 141456972, 2478885421]);
+                   vec!(3676831399, 3183332890, 2834741178, 3854698763, 2717568474,
+                        1576568959, 3507990155, 179069555, 141456972, 2478885421));
     }
     #[test]
     fn test_rng_64_true_values() {
         let seed = &[1, 23, 456, 7890, 12345];
         let mut ra: Isaac64Rng = SeedableRng::from_seed(seed);
         // Regression test that isaac is actually using the above vector
-        let v = slice::from_fn(10, |_| ra.next_u64());
+        let v = Vec::from_fn(10, |_| ra.next_u64());
         assert_eq!(v,
-                   ~[547121783600835980, 14377643087320773276, 17351601304698403469,
-                     1238879483818134882, 11952566807690396487, 13970131091560099343,
-                     4469761996653280935, 15552757044682284409, 6860251611068737823,
-                     13722198873481261842]);
+                   vec!(547121783600835980, 14377643087320773276, 17351601304698403469,
+                        1238879483818134882, 11952566807690396487, 13970131091560099343,
+                        4469761996653280935, 15552757044682284409, 6860251611068737823,
+                        13722198873481261842));
 
         let seed = &[12345, 67890, 54321, 9876];
         let mut rb: Isaac64Rng = SeedableRng::from_seed(seed);
         // skip forward to the 10000th number
         for _ in range(0, 10000) { rb.next_u64(); }
 
-        let v = slice::from_fn(10, |_| rb.next_u64());
+        let v = Vec::from_fn(10, |_| rb.next_u64());
         assert_eq!(v,
-                   ~[18143823860592706164, 8491801882678285927, 2699425367717515619,
-                     17196852593171130876, 2606123525235546165, 15790932315217671084,
-                     596345674630742204, 9947027391921273664, 11788097613744130851,
-                     10391409374914919106]);
+                   vec!(18143823860592706164, 8491801882678285927, 2699425367717515619,
+                        17196852593171130876, 2606123525235546165, 15790932315217671084,
+                        596345674630742204, 9947027391921273664, 11788097613744130851,
+                        10391409374914919106));
     }
 }

src/librand/lib.rs

@@ -73,6 +73,7 @@ println!("{:?}", tuple_ptr)
 #![feature(macro_rules, managed_boxes, phase)]
 
 #![allow(visible_private_types)] // NOTE: remove after a stage0 snap
+#![deny(deprecated_owned_vector)]
 
 #[cfg(test)]
 #[phase(syntax, link)] extern crate log;
@@ -82,7 +83,6 @@ use std::io::IoResult;
 use std::kinds::marker;
 use std::local_data;
 use std::str;
-use std::slice;
 
 pub use isaac::{IsaacRng, Isaac64Rng};
 pub use os::OSRng;
@@ -199,12 +199,12 @@ pub trait Rng {
     /// use rand::{task_rng, Rng};
     ///
     /// let mut rng = task_rng();
-    /// let x: ~[uint] = rng.gen_vec(10);
-    /// println!("{:?}", x);
-    /// println!("{:?}", rng.gen_vec::<(f64, bool)>(5));
+    /// let x: Vec<uint> = rng.gen_vec(10);
+    /// println!("{}", x);
+    /// println!("{}", rng.gen_vec::<(f64, bool)>(5));
     /// ```
-    fn gen_vec<T: Rand>(&mut self, len: uint) -> ~[T] {
-        slice::from_fn(len, |_| self.gen())
+    fn gen_vec<T: Rand>(&mut self, len: uint) -> Vec<T> {
+        Vec::from_fn(len, |_| self.gen())
     }
 
     /// Generate a random value in the range [`low`, `high`). Fails if
@@ -300,12 +300,11 @@ pub trait Rng {
     /// ```rust
     /// use rand::{task_rng, Rng};
     ///
-    /// println!("{:?}", task_rng().shuffle(~[1,2,3]));
+    /// println!("{}", task_rng().shuffle(vec!(1,2,3)));
     /// ```
-    fn shuffle<T>(&mut self, values: ~[T]) -> ~[T] {
-        let mut v = values;
-        self.shuffle_mut(v);
-        v
+    fn shuffle<T>(&mut self, mut values: Vec<T>) -> Vec<T> {
+        self.shuffle_mut(values.as_mut_slice());
+        values
     }
 
     /// Shuffle a mutable vector in place.
@@ -341,10 +340,10 @@ pub trait Rng {
     ///
     /// let mut rng = task_rng();
     /// let sample = rng.sample(range(1, 100), 5);
-    /// println!("{:?}", sample);
+    /// println!("{}", sample);
     /// ```
-    fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
-        let mut reservoir : ~[A] = slice::with_capacity(n);
+    fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> Vec<A> {
+        let mut reservoir = Vec::with_capacity(n);
         for (i, elem) in iter.enumerate() {
             if i < n {
                 reservoir.push(elem);
@@ -353,7 +352,7 @@ pub trait Rng {
 
             let k = self.gen_range(0, i + 1);
             if k < reservoir.len() {
-                reservoir[k] = elem
+                *reservoir.get_mut(k) = elem
             }
         }
         reservoir
@@ -695,7 +694,6 @@ pub struct Closed01<F>(F);
 
 #[cfg(test)]
 mod test {
-    use std::slice;
     use super::{Rng, task_rng, random, SeedableRng, StdRng};
 
     struct ConstRng { i: u64 }
@@ -714,8 +712,8 @@ mod test {
         let lengths = [0, 1, 2, 3, 4, 5, 6, 7,
                        80, 81, 82, 83, 84, 85, 86, 87];
         for &n in lengths.iter() {
-            let mut v = slice::from_elem(n, 0u8);
-            r.fill_bytes(v);
+            let mut v = Vec::from_elem(n, 0u8);
+            r.fill_bytes(v.as_mut_slice());
 
             // use this to get nicer error messages.
             for (i, &byte) in v.iter().enumerate() {
@@ -813,16 +811,16 @@ mod test {
     #[test]
     fn test_shuffle() {
         let mut r = task_rng();
-        let empty: ~[int] = ~[];
-        assert_eq!(r.shuffle(~[]), empty);
-        assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]);
+        let empty = Vec::<int>::new();
+        assert_eq!(r.shuffle(vec!()), empty);
+        assert_eq!(r.shuffle(vec!(1, 1, 1)), vec!(1, 1, 1));
     }
 
     #[test]
     fn test_task_rng() {
         let mut r = task_rng();
         r.gen::<int>();
-        assert_eq!(r.shuffle(~[1, 1, 1]), ~[1, 1, 1]);
+        assert_eq!(r.shuffle(vec!(1, 1, 1)), vec!(1, 1, 1));
         assert_eq!(r.gen_range(0u, 1u), 0u);
     }
 
@@ -844,7 +842,7 @@ mod test {
         let max_val = 100;
 
         let mut r = task_rng();
-        let vals = range(min_val, max_val).collect::<~[int]>();
+        let vals = range(min_val, max_val).collect::<Vec<int>>();
         let small_sample = r.sample(vals.iter(), 5);
         let large_sample = r.sample(vals.iter(), vals.len() + 5);
 
@@ -870,7 +868,7 @@ mod test {
         let mut r: StdRng = SeedableRng::from_seed(s.as_slice());
         let string1 = r.gen_ascii_str(100);
 
-        r.reseed(s);
+        r.reseed(s.as_slice());
 
         let string2 = r.gen_ascii_str(100);
         assert_eq!(string1, string2);

src/librand/os.rs

@@ -204,7 +204,7 @@ mod test {
     #[test]
     fn test_os_rng_tasks() {
 
-        let mut txs = ~[];
+        let mut txs = vec!();
         for _ in range(0, 20) {
             let (tx, rx) = channel();
             txs.push(tx);

src/librand/reader.rs

@@ -68,6 +68,7 @@ impl<R: Reader> Rng for ReaderRng<R> {
 }
 
 #[cfg(test)]
+#[allow(deprecated_owned_vector)]
 mod test {
     use super::ReaderRng;
     use std::io::MemReader;