Update users for the std::rand -> librand move.

Author: huonw

src/doc/guide-tasks.md

@@ -50,13 +50,13 @@ concurrency at this writing:
 * [`sync::DuplexStream`] - An extension of `pipes::stream` that allows both sending and receiving,
 * [`sync::SyncChan`] - An extension of `pipes::stream` that provides synchronous message sending,
 * [`sync::SyncPort`] - An extension of `pipes::stream` that acknowledges each message received,
-* [`sync::rendezvous`] - Creates a stream whose channel, upon sending a message, blocks until the 
+* [`sync::rendezvous`] - Creates a stream whose channel, upon sending a message, blocks until the
     message is received.
 * [`sync::Arc`] - The Arc (atomically reference counted) type, for safely sharing immutable data,
 * [`sync::RWArc`] - A dual-mode Arc protected by a reader-writer lock,
 * [`sync::MutexArc`] - An Arc with mutable data protected by a blocking mutex,
 * [`sync::Semaphore`] - A counting, blocking, bounded-waiting semaphore,
-* [`sync::Mutex`] - A blocking, bounded-waiting, mutual exclusion lock with an associated 
+* [`sync::Mutex`] - A blocking, bounded-waiting, mutual exclusion lock with an associated
     FIFO condition variable,
 * [`sync::RWLock`] - A blocking, no-starvation, reader-writer lock with an associated condvar,
 * [`sync::Barrier`] - A barrier enables multiple tasks to synchronize the beginning
@@ -343,8 +343,8 @@ a single large vector of floats. Each task needs the full vector to perform its
 
 ~~~
 # extern crate sync;
+ extern crate rand;
 # use std::vec;
-# use std::rand;
 use sync::Arc;
 
 fn pnorm(nums: &~[f64], p: uint) -> f64 {
@@ -376,9 +376,9 @@ created by the line
 
 ~~~
 # extern crate sync;
+# extern crate rand;
 # use sync::Arc;
 # use std::vec;
-# use std::rand;
 # fn main() {
 # let numbers = vec::from_fn(1000000, |_| rand::random::<f64>());
 let numbers_arc=Arc::new(numbers);
@@ -389,9 +389,9 @@ and a clone of it is sent to each task
 
 ~~~
 # extern crate sync;
+# extern crate rand;
 # use sync::Arc;
 # use std::vec;
-# use std::rand;
 # fn main() {
 # let numbers=vec::from_fn(1000000, |_| rand::random::<f64>());
 # let numbers_arc = Arc::new(numbers);
@@ -406,9 +406,9 @@ Each task recovers the underlying data by
 
 ~~~
 # extern crate sync;
+# extern crate rand;
 # use sync::Arc;
 # use std::vec;
-# use std::rand;
 # fn main() {
 # let numbers=vec::from_fn(1000000, |_| rand::random::<f64>());
 # let numbers_arc=Arc::new(numbers);

src/doc/tutorial.md

@@ -2529,7 +2529,7 @@ of type `ABC` can be randomly generated and converted to a string:
 #[deriving(Eq)]
 struct Circle { radius: f64 }
 
-#[deriving(Rand, Show)]
+#[deriving(Clone, Show)]
 enum ABC { A, B, C }
 ~~~
 

src/etc/generate-deriving-span-tests.py

@@ -39,6 +39,7 @@
 
 #[feature(struct_variant)];
 extern crate extra;
+extern crate rand;
 
 {error_deriving}
 struct Error;

src/libcollections/bitv.rs

@@ -947,8 +947,8 @@ mod tests {
 
     use std::uint;
     use std::vec;
-    use std::rand;
-    use std::rand::Rng;
+    use rand;
+    use rand::Rng;
 
     static BENCH_BITS : uint = 1 << 14;
 

src/libcollections/deque.rs

@@ -44,8 +44,9 @@ pub mod bench {
     extern crate test;
     use self::test::BenchHarness;
     use std::container::MutableMap;
-    use std::{vec, rand};
-    use std::rand::Rng;
+    use std::vec;
+    use rand;
+    use rand::Rng;
 
     pub fn insert_rand_n<M:MutableMap<uint,uint>>(n: uint,
                                                   map: &mut M,

src/libcollections/dlist.rs

@@ -633,7 +633,7 @@ mod tests {
     extern crate test;
     use self::test::BenchHarness;
     use deque::Deque;
-    use std::rand;
+    use rand;
     use super::{DList, Node, ListInsertion};
 
     pub fn check_links<T>(list: &DList<T>) {

src/libcollections/hashmap.rs

@@ -61,8 +61,8 @@ use std::iter::{FilterMap, Chain, Repeat, Zip};
 use std::iter;
 use std::mem::replace;
 use std::num;
-use std::rand::Rng;
-use std::rand;
+use rand::Rng;
+use rand;
 use std::vec::{Items, MutItems};
 use std::vec_ng::Vec;
 use std::vec_ng;

src/libcollections/lib.rs

@@ -23,6 +23,8 @@
 #[allow(unrecognized_lint)];
 #[allow(default_type_param_usage)];
 
+extern crate rand;
+
 #[cfg(test)] extern crate test;
 
 pub use bitv::Bitv;

src/libcollections/treemap.rs

@@ -1009,8 +1009,8 @@ mod test_treemap {
 
     use super::{TreeMap, TreeNode};
 
-    use std::rand::Rng;
-    use std::rand;
+    use rand::Rng;
+    use rand;
 
     #[test]
     fn find_empty() {

src/libcollections/trie.rs

@@ -898,7 +898,7 @@ mod test_map {
 mod bench_map {
     extern crate test;
     use super::TrieMap;
-    use std::rand::{weak_rng, Rng};
+    use rand::{weak_rng, Rng};
     use self::test::BenchHarness;
 
     #[bench]

src/libextra/lib.rs

@@ -34,9 +34,10 @@ Rust extras are part of the standard Rust distribution.
 #[deny(non_camel_case_types)];
 #[deny(missing_doc)];
 
-extern crate sync;
-extern crate serialize;
 extern crate collections;
+extern crate rand;
+extern crate serialize;
+extern crate sync;
 extern crate time;
 
 // Utility modules

src/libextra/tempfile.rs

@@ -12,8 +12,8 @@
 
 
 use std::os;
-use std::rand::Rng;
-use std::rand;
+use rand::Rng;
+use rand;
 use std::io;
 use std::io::fs;
 

src/libflate/lib.rs

@@ -90,9 +90,10 @@ pub fn inflate_bytes_zlib(bytes: &[u8]) -> CVec<u8> {
 
 #[cfg(test)]
 mod tests {
+    extern crate rand;
+
     use super::{inflate_bytes, deflate_bytes};
-    use std::rand;
-    use std::rand::Rng;
+    use self::rand::Rng;
 
     #[test]
     fn test_flate_round_trip() {

src/libgreen/lib.rs

@@ -175,6 +175,8 @@
 #[feature(macro_rules)];
 #[allow(visible_private_types)];
 
+extern crate rand;
+
 use std::mem::replace;
 use std::os;
 use std::rt::crate_map;

src/libgreen/sched.rs

@@ -9,7 +9,6 @@
 // except according to those terms.
 
 use std::cast;
-use std::rand::{XorShiftRng, Rng, Rand};
 use std::rt::local::Local;
 use std::rt::rtio::{RemoteCallback, PausableIdleCallback, Callback, EventLoop};
 use std::rt::task::BlockedTask;
@@ -18,6 +17,8 @@ use std::sync::deque;
 use std::unstable::mutex::NativeMutex;
 use std::raw;
 
+use rand::{XorShiftRng, Rng, Rand};
+
 use TaskState;
 use context::Context;
 use coroutine::Coroutine;
@@ -957,7 +958,7 @@ fn new_sched_rng() -> XorShiftRng {
 fn new_sched_rng() -> XorShiftRng {
     use std::libc;
     use std::mem;
-    use std::rand::SeedableRng;
+    use rand::SeedableRng;
 
     let fd = "/dev/urandom".with_c_str(|name| {
         unsafe { libc::open(name, libc::O_RDONLY, 0) }

src/libnum/bigint.rs

@@ -24,7 +24,7 @@ use std::from_str::FromStr;
 use std::num::CheckedDiv;
 use std::num::{Bitwise, ToPrimitive, FromPrimitive};
 use std::num::{Zero, One, ToStrRadix, FromStrRadix};
-use std::rand::Rng;
+use rand::Rng;
 use std::str;
 use std::uint;
 use std::vec;
@@ -1470,7 +1470,7 @@ mod biguint_tests {
     use std::num::{Zero, One, FromStrRadix, ToStrRadix};
     use std::num::{ToPrimitive, FromPrimitive};
     use std::num::CheckedDiv;
-    use std::rand::{task_rng};
+    use rand::{task_rng};
     use std::str;
     use std::u64;
     use std::vec;
@@ -2205,7 +2205,7 @@ mod bigint_tests {
     use std::num::CheckedDiv;
     use std::num::{Zero, One, FromStrRadix, ToStrRadix};
     use std::num::{ToPrimitive, FromPrimitive};
-    use std::rand::{task_rng};
+    use rand::{task_rng};
     use std::u64;
 
     #[test]

src/libnum/lib.rs

@@ -15,6 +15,8 @@
 #[crate_type = "dylib"];
 #[license = "MIT/ASL2"];
 
+extern crate rand;
+
 pub mod bigint;
 pub mod rational;
 pub mod complex;

src/librustc/util/sha2.rs

@@ -524,12 +524,14 @@ static H256: [u32, ..8] = [
 
 #[cfg(test)]
 mod tests {
+    extern crate rand;
+
     use super::{Digest, Sha256, FixedBuffer};
     use std::num::Bounded;
     use std::vec;
     use std::vec_ng::Vec;
-    use std::rand::isaac::IsaacRng;
-    use std::rand::Rng;
+    use self::rand::isaac::IsaacRng;
+    use self::rand::Rng;
     use serialize::hex::FromHex;
 
     // A normal addition - no overflow occurs

src/libserialize/base64.rs

@@ -263,6 +263,7 @@ impl<'a> FromBase64 for &'a str {
 #[cfg(test)]
 mod tests {
     extern crate test;
+    extern crate rand;
     use self::test::BenchHarness;
     use base64::{Config, FromBase64, ToBase64, STANDARD, URL_SAFE};
 
@@ -335,7 +336,7 @@ mod tests {
 
     #[test]
     fn test_base64_random() {
-        use std::rand::{task_rng, random, Rng};
+        use self::rand::{task_rng, random, Rng};
         use std::vec;
 
         for _ in range(0, 1000) {

src/libsync/arc.rs

@@ -18,23 +18,27 @@
  * With simple pipes, without Arc, a copy would have to be made for each task.
  *
  * ```rust
+ * extern crate sync;
+ * extern crate rand;
  * use sync::Arc;
- * use std::{rand, vec};
+ * use std::vec;
  *
- * let numbers = vec::from_fn(100, |i| (i as f32) * rand::random());
- * let shared_numbers = Arc::new(numbers);
+ * fn main() {
+ *     let numbers = vec::from_fn(100, |i| (i as f32) * rand::random());
+ *     let shared_numbers = Arc::new(numbers);
  *
- *   for _ in range(0, 10) {
- *       let (port, chan) = Chan::new();
- *       chan.send(shared_numbers.clone());
+ *     for _ in range(0, 10) {
+ *         let (port, chan) = Chan::new();
+ *         chan.send(shared_numbers.clone());
  *
- *       spawn(proc() {
- *           let shared_numbers = port.recv();
- *           let local_numbers = shared_numbers.get();
+ *         spawn(proc() {
+ *             let shared_numbers = port.recv();
+ *             let local_numbers = shared_numbers.get();
  *
- *           // Work with the local numbers
- *       });
- *   }
+ *             // Work with the local numbers
+ *         });
+ *     }
+ * }
  * ```
  */
 

src/libsyntax/ext/deriving/generic.rs

@@ -216,7 +216,7 @@ pub struct TraitDef<'a> {
 pub struct MethodDef<'a> {
     /// name of the method
     name: &'a str,
-    /// List of generics, e.g. `R: std::rand::Rng`
+    /// List of generics, e.g. `R: rand::Rng`
     generics: LifetimeBounds<'a>,
 
     /// Whether there is a self argument (outer Option) i.e. whether

src/libuuid/lib.rs

@@ -62,6 +62,8 @@ Examples of string representations:
 // test harness access
 #[cfg(test)]
 extern crate test;
+
+extern crate rand;
 extern crate serialize;
 
 use std::cast::{transmute,transmute_copy};
@@ -71,11 +73,11 @@ use std::fmt;
 use std::from_str::FromStr;
 use std::hash::{Hash, sip};
 use std::num::FromStrRadix;
-use std::rand::Rng;
-use std::rand;
 use std::str;
 use std::vec;
 
+use rand::Rng;
+
 use serialize::{Encoder, Encodable, Decoder, Decodable};
 
 /// A 128-bit (16 byte) buffer containing the ID
@@ -519,12 +521,12 @@ impl rand::Rand for Uuid {
 #[cfg(test)]
 mod test {
     extern crate collections;
+    extern crate rand;
 
     use super::{Uuid, VariantMicrosoft, VariantNCS, VariantRFC4122,
                 Version1Mac, Version2Dce, Version3Md5, Version4Random,
                 Version5Sha1};
     use std::str;
-    use std::rand;
     use std::io::MemWriter;
 
     #[test]

src/test/bench/core-map.rs

@@ -9,11 +9,12 @@
 // except according to those terms.
 
 extern crate collections;
+extern crate rand;
 extern crate time;
 
 use collections::{TrieMap, TreeMap, HashMap, HashSet};
 use std::os;
-use std::rand::{Rng, IsaacRng, SeedableRng};
+use rand::{Rng, IsaacRng, SeedableRng};
 use std::uint;
 use std::vec;