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 ~[].

diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs
index 2e2224bde842cf73d2e22eab451a04f3c6429672..d44dfbef253780d591f50a4f86e1a1645f4d8e93 100644 (file)
--- a/src/libflate/lib.rs
+++ b/src/libflate/lib.rs
@@ -112,7 +112,7 @@ fn test_flate_round_trip() {
         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());

diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs
index 2323088027860faf0e1298d168a5abad6a2b103e..af63e52e885aa5ab0b3a22c92df82fa30dc699fb 100644 (file)
--- a/src/librand/distributions/mod.rs
+++ b/src/librand/distributions/mod.rs
@@ -91,9 +91,9 @@ 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.
@@ -101,8 +101,8 @@ pub struct Weighted<T> {
 /// }
 /// ```
 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 @@ fn ind_sample<R: Rng>(&self, rng: &mut R) -> 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 @@ fn ind_sample<R: Rng>(&self, rng: &mut R) -> 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 @@ fn ind_sample<R: Rng>(&self, rng: &mut R) -> T {
             }
             modifier /= 2;
         }
-        return self.items[idx + 1].item.clone();
+        return self.items.get(idx + 1).item.clone();
     }
 }
 
@@ -297,54 +297,54 @@ macro_rules! t (
             }}
         );
 
-        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 }));
     }
 }

diff --git a/src/librand/isaac.rs b/src/librand/isaac.rs
index de3d471c7bd0d412f44973fa4e6975ab951f5ddb..23371ed2bd8bc4ac8405e97d5e25f895c37bbdf7 100644 (file)
--- a/src/librand/isaac.rs
+++ b/src/librand/isaac.rs
@@ -441,7 +441,6 @@ fn from_seed(seed: &'a [u64]) -> 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 @@ fn test_rng_32_reseed() {
         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 @@ fn test_rng_64_reseed() {
         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 @@ fn test_rng_32_true_values() {
         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));
     }
 }

diff --git a/src/librand/lib.rs b/src/librand/lib.rs
index 56d52e784661926134313eeac8564957fb106d62..2b710baeff0744e9343de18f4ccdcded5c8b5faf 100644 (file)
--- a/src/librand/lib.rs
+++ b/src/librand/lib.rs
@@ -73,6 +73,7 @@
 #![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::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 @@ fn gen<T: Rand>(&mut self) -> T {
     /// 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 @@ fn choose_option<'a, T>(&mut self, values: &'a [T]) -> Option<&'a T> {
     /// ```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 @@ fn shuffle_mut<T>(&mut self, values: &mut [T]) {
     ///
     /// 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 @@ fn sample<A, T: Iterator<A>>(&mut self, iter: T, n: uint) -> ~[A] {
 
             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 fn random<T: Rand>() -> T {
 
 #[cfg(test)]
 mod test {
-    use std::slice;
     use super::{Rng, task_rng, random, SeedableRng, StdRng};
 
     struct ConstRng { i: u64 }
@@ -714,8 +712,8 @@ fn test_fill_bytes_default() {
         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 @@ fn test_choose_option() {
     #[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 @@ fn test_sample() {
         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 @@ fn test_std_rng_reseed() {
         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);

diff --git a/src/librand/os.rs b/src/librand/os.rs
index 86960af7a4d84e143f3e55c1afbdfd542545ce1c..762e09fb3f51130efc0aaad3cf4478a6cbf7902c 100644 (file)
--- a/src/librand/os.rs
+++ b/src/librand/os.rs
@@ -204,7 +204,7 @@ fn test_os_rng() {
     #[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);

diff --git a/src/librand/reader.rs b/src/librand/reader.rs
index 76a0efc92a99994022e45878c84791b05734d4dc..dff821d83298f93f716bdc5656ac8edefcdfc21c 100644 (file)
--- a/src/librand/reader.rs
+++ b/src/librand/reader.rs
@@ -68,6 +68,7 @@ fn fill_bytes(&mut self, v: &mut [u8]) {
 }
 
 #[cfg(test)]
+#[allow(deprecated_owned_vector)]
 mod test {
     use super::ReaderRng;
     use std::io::MemReader;

diff --git a/src/librand/reseeding.rs b/src/librand/reseeding.rs
index c069c7389c2112ba2e5cbbee47e2a807443f30a8..fe2ff319c1cadb2ad4ffb0e440fa9d475648278a 100644 (file)
--- a/src/librand/reseeding.rs
+++ b/src/librand/reseeding.rs
@@ -205,8 +205,8 @@ fn test_rng_reseed() {
     #[test]
     fn test_rng_fill_bytes() {
         use task_rng;
-        let mut v = ~[0u8, .. fill_bytes_v_len];
-        task_rng().fill_bytes(v);
+        let mut v = Vec::from_elem(fill_bytes_v_len, 0u8);
+        task_rng().fill_bytes(v.as_mut_slice());
 
         // Sanity test: if we've gotten here, `fill_bytes` has not infinitely
         // recursed.

diff --git a/src/libstd/slice.rs b/src/libstd/slice.rs
index bb6cb7a3e25d15bcd1202e2d1394860537cd9672..3e1f62da039ef55fd93c9666104ab01e21770a79 100644 (file)
--- a/src/libstd/slice.rs
+++ b/src/libstd/slice.rs
@@ -3442,19 +3442,21 @@ fn test_reverse() {
 
     #[test]
     fn test_sort() {
+        use realstd::slice::Vector;
+        use realstd::clone::Clone;
         for len in range(4u, 25) {
             for _ in range(0, 100) {
                 let mut v = task_rng().gen_vec::<uint>(len);
                 let mut v1 = v.clone();
 
-                v.sort();
-                assert!(v.windows(2).all(|w| w[0] <= w[1]));
+                v.as_mut_slice().sort();
+                assert!(v.as_slice().windows(2).all(|w| w[0] <= w[1]));
 
-                v1.sort_by(|a, b| a.cmp(b));
-                assert!(v1.windows(2).all(|w| w[0] <= w[1]));
+                v1.as_mut_slice().sort_by(|a, b| a.cmp(b));
+                assert!(v1.as_slice().windows(2).all(|w| w[0] <= w[1]));
 
-                v1.sort_by(|a, b| b.cmp(a));
-                assert!(v1.windows(2).all(|w| w[0] >= w[1]));
+                v1.as_mut_slice().sort_by(|a, b| b.cmp(a));
+                assert!(v1.as_slice().windows(2).all(|w| w[0] >= w[1]));
             }
         }
 
@@ -4487,8 +4489,8 @@ fn random_removes(bh: &mut BenchHarness) {
     fn sort_random_small(bh: &mut BenchHarness) {
         let mut rng = weak_rng();
         bh.iter(|| {
-            let mut v: ~[u64] = rng.gen_vec(5);
-            v.sort();
+            let mut v = rng.gen_vec::<u64>(5);
+            v.as_mut_slice().sort();
         });
         bh.bytes = 5 * mem::size_of::<u64>() as u64;
     }
@@ -4497,8 +4499,8 @@ fn sort_random_small(bh: &mut BenchHarness) {
     fn sort_random_medium(bh: &mut BenchHarness) {
         let mut rng = weak_rng();
         bh.iter(|| {
-            let mut v: ~[u64] = rng.gen_vec(100);
-            v.sort();
+            let mut v = rng.gen_vec::<u64>(100);
+            v.as_mut_slice().sort();
         });
         bh.bytes = 100 * mem::size_of::<u64>() as u64;
     }
@@ -4507,8 +4509,8 @@ fn sort_random_medium(bh: &mut BenchHarness) {
     fn sort_random_large(bh: &mut BenchHarness) {
         let mut rng = weak_rng();
         bh.iter(|| {
-            let mut v: ~[u64] = rng.gen_vec(10000);
-            v.sort();
+            let mut v = rng.gen_vec::<u64>(10000);
+            v.as_mut_slice().sort();
         });
         bh.bytes = 10000 * mem::size_of::<u64>() as u64;
     }
@@ -4528,7 +4530,7 @@ fn sort_sorted(bh: &mut BenchHarness) {
     fn sort_big_random_small(bh: &mut BenchHarness) {
         let mut rng = weak_rng();
         bh.iter(|| {
-            let mut v: ~[BigSortable] = rng.gen_vec(5);
+            let mut v = rng.gen_vec::<BigSortable>(5);
             v.sort();
         });
         bh.bytes = 5 * mem::size_of::<BigSortable>() as u64;
@@ -4538,7 +4540,7 @@ fn sort_big_random_small(bh: &mut BenchHarness) {
     fn sort_big_random_medium(bh: &mut BenchHarness) {
         let mut rng = weak_rng();
         bh.iter(|| {
-            let mut v: ~[BigSortable] = rng.gen_vec(100);
+            let mut v = rng.gen_vec::<BigSortable>(100);
             v.sort();
         });
         bh.bytes = 100 * mem::size_of::<BigSortable>() as u64;
@@ -4548,7 +4550,7 @@ fn sort_big_random_medium(bh: &mut BenchHarness) {
     fn sort_big_random_large(bh: &mut BenchHarness) {
         let mut rng = weak_rng();
         bh.iter(|| {
-            let mut v: ~[BigSortable] = rng.gen_vec(10000);
+            let mut v = rng.gen_vec::<BigSortable>(10000);
             v.sort();
         });
         bh.bytes = 10000 * mem::size_of::<BigSortable>() as u64;

diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs
index d1e4a1c0472be18f721104bbdb546f2a4a973857..f70cb908b52d0a5d62d2022fd929dcce9493da13 100644 (file)
--- a/src/libuuid/lib.rs
+++ b/src/libuuid/lib.rs
@@ -196,7 +196,7 @@ pub fn new(v: UuidVersion) -> Option<Uuid> {
     pub fn new_v4() -> Uuid {
         let ub = rand::task_rng().gen_vec(16);
         let mut uuid = Uuid{ bytes: [0, .. 16] };
-        slice::bytes::copy_memory(uuid.bytes, ub);
+        slice::bytes::copy_memory(uuid.bytes, ub.as_slice());
         uuid.set_variant(VariantRFC4122);
         uuid.set_version(Version4Random);
         uuid
@@ -510,7 +510,7 @@ impl rand::Rand for Uuid {
     fn rand<R: rand::Rng>(rng: &mut R) -> Uuid {
         let ub = rng.gen_vec(16);
         let mut uuid = Uuid{ bytes: [0, .. 16] };
-        slice::bytes::copy_memory(uuid.bytes, ub);
+        slice::bytes::copy_memory(uuid.bytes, ub.as_slice());
         uuid.set_variant(VariantRFC4122);
         uuid.set_version(Version4Random);
         uuid

diff --git a/src/test/run-pass/vector-sort-failure-safe.rs b/src/test/run-pass/vector-sort-failure-safe.rs
index e307ae36f96c1da6781cf399a3c9e276d37572f5..0190355e127ca690b4cd911f056981baed042115 100644 (file)
--- a/src/test/run-pass/vector-sort-failure-safe.rs
+++ b/src/test/run-pass/vector-sort-failure-safe.rs
@@ -52,7 +52,7 @@ pub fn main() {
             // work out the total number of comparisons required to sort
             // this array...
             let mut count = 0;
-            main.clone().sort_by(|a, b| { count += 1; a.cmp(b) });
+            main.clone().as_mut_slice().sort_by(|a, b| { count += 1; a.cmp(b) });
 
             // ... and then fail on each and every single one.
             for fail_countdown in range(0, count) {
@@ -67,7 +67,7 @@ pub fn main() {
                 task::try(proc() {
                         let mut v = v;
                         let mut fail_countdown = fail_countdown;
-                        v.sort_by(|a, b| {
+                        v.as_mut_slice().sort_by(|a, b| {
                                 if fail_countdown == 0 {
                                     fail!()
                                 }