diff --git a/src/libflate/lib.rs b/src/libflate/lib.rs index 2e2224bde84..d44dfbef253 100644 --- a/src/libflate/lib.rs +++ b/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()); diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 23230880278..af63e52e885 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -91,9 +91,9 @@ pub struct Weighted { /// ```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 { /// } /// ``` pub struct WeightedChoice { - pub items: ~[Weighted], - pub weight_range: Range + items: Vec>, + weight_range: Range } impl WeightedChoice { @@ -112,7 +112,7 @@ impl WeightedChoice { /// - `v` is empty /// - the total weight is 0 /// - the total weight is larger than a `uint` can contain. - pub fn new(mut items: ~[Weighted]) -> WeightedChoice { + pub fn new(mut items: Vec>) -> WeightedChoice { // 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 IndependentSample for WeightedChoice { 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 IndependentSample for WeightedChoice { // 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 IndependentSample for WeightedChoice { } 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::::new(~[]); + WeightedChoice::::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 de3d471c7bd..23371ed2bd8 100644 --- a/src/librand/isaac.rs +++ b/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)); } } diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 56d52e78466..2b710baeff0 100644 --- a/src/librand/lib.rs +++ b/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 = rng.gen_vec(10); + /// println!("{}", x); + /// println!("{}", rng.gen_vec::<(f64, bool)>(5)); /// ``` - fn gen_vec(&mut self, len: uint) -> ~[T] { - slice::from_fn(len, |_| self.gen()) + fn gen_vec(&mut self, len: uint) -> Vec { + 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(&mut self, values: ~[T]) -> ~[T] { - let mut v = values; - self.shuffle_mut(v); - v + fn shuffle(&mut self, mut values: Vec) -> Vec { + 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>(&mut self, iter: T, n: uint) -> ~[A] { - let mut reservoir : ~[A] = slice::with_capacity(n); + fn sample>(&mut self, iter: T, n: uint) -> Vec { + 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); #[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::::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::(); - 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::>(); 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); diff --git a/src/librand/os.rs b/src/librand/os.rs index 86960af7a4d..762e09fb3f5 100644 --- a/src/librand/os.rs +++ b/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); diff --git a/src/librand/reader.rs b/src/librand/reader.rs index 76a0efc92a9..dff821d8329 100644 --- a/src/librand/reader.rs +++ b/src/librand/reader.rs @@ -68,6 +68,7 @@ impl Rng for ReaderRng { } #[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 c069c7389c2..fe2ff319c1c 100644 --- a/src/librand/reseeding.rs +++ b/src/librand/reseeding.rs @@ -205,8 +205,8 @@ mod test { #[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 bb6cb7a3e25..3e1f62da039 100644 --- a/src/libstd/slice.rs +++ b/src/libstd/slice.rs @@ -3442,19 +3442,21 @@ mod tests { #[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::(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 @@ mod bench { 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::(5); + v.as_mut_slice().sort(); }); bh.bytes = 5 * mem::size_of::() as u64; } @@ -4497,8 +4499,8 @@ mod bench { 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::(100); + v.as_mut_slice().sort(); }); bh.bytes = 100 * mem::size_of::() as u64; } @@ -4507,8 +4509,8 @@ mod bench { 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::(10000); + v.as_mut_slice().sort(); }); bh.bytes = 10000 * mem::size_of::() as u64; } @@ -4528,7 +4530,7 @@ mod bench { 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::(5); v.sort(); }); bh.bytes = 5 * mem::size_of::() as u64; @@ -4538,7 +4540,7 @@ mod bench { 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::(100); v.sort(); }); bh.bytes = 100 * mem::size_of::() as u64; @@ -4548,7 +4550,7 @@ mod bench { 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::(10000); v.sort(); }); bh.bytes = 10000 * mem::size_of::() as u64; diff --git a/src/libuuid/lib.rs b/src/libuuid/lib.rs index d1e4a1c0472..f70cb908b52 100644 --- a/src/libuuid/lib.rs +++ b/src/libuuid/lib.rs @@ -196,7 +196,7 @@ impl 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(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 e307ae36f96..0190355e127 100644 --- 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!() }