std: Move rand to librand.

This functionality is not super-core and so doesn't need to be included
in std. It's possible that std may need rand (it does a little bit now,
for io::test) in which case the functionality required could be moved to
a secret hidden module and reexposed by librand.

Unfortunately, using #[deprecated] here is hard: there's too much to
mock to make it feasible, since we have to ensure that programs still
typecheck to reach the linting phase.

Author: huonw

mk/crates.mk

@@ -50,14 +50,14 @@
 ################################################################################
 
 TARGET_CRATES := std extra green rustuv native flate arena glob term semver \
-                 uuid serialize sync getopts collections num test time
+                 uuid serialize sync getopts collections num test time rand
 HOST_CRATES := syntax rustc rustdoc fourcc hexfloat
 CRATES := $(TARGET_CRATES) $(HOST_CRATES)
 TOOLS := compiletest rustdoc rustc
 
 DEPS_std := native:rustrt native:compiler-rt
-DEPS_extra := std term sync serialize getopts collections time
-DEPS_green := std native:context_switch
+DEPS_extra := std term sync serialize getopts collections time rand
+DEPS_green := std rand native:context_switch
 DEPS_rustuv := std native:uv native:uv_support
 DEPS_native := std
 DEPS_syntax := std term serialize collections
@@ -71,15 +71,16 @@ DEPS_glob := std
 DEPS_serialize := std collections
 DEPS_term := std collections
 DEPS_semver := std
-DEPS_uuid := std serialize
+DEPS_uuid := std serialize rand
 DEPS_sync := std
 DEPS_getopts := std
-DEPS_collections := std
+DEPS_collections := std rand
 DEPS_fourcc := syntax std
 DEPS_hexfloat := syntax std
-DEPS_num := std
+DEPS_num := std rand
 DEPS_test := std extra collections getopts serialize term
 DEPS_time := std serialize
+DEPS_rand := std
 
 TOOL_DEPS_compiletest := test green rustuv getopts
 TOOL_DEPS_rustdoc := rustdoc native

src/etc/ziggurat_tables.py

@@ -11,7 +11,7 @@
 # except according to those terms.
 
 # This creates the tables used for distributions implemented using the
-# ziggurat algorithm in `std::rand::distributions;`. They are
+# ziggurat algorithm in `rand::distributions;`. They are
 # (basically) the tables as used in the ZIGNOR variant (Doornik 2005).
 # They are changed rarely, so the generated file should be checked in
 # to git.

src/libstd/rand/distributions/exponential.rs renamed to src/librand/distributions/exponential.rs

@@ -10,9 +10,9 @@
 
 //! The exponential distribution.
 
-use num::Float;
-use rand::{Rng, Rand};
-use rand::distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample};
+use std::num::Float;
+use {Rng, Rand};
+use distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample};
 
 /// A wrapper around an `f64` to generate Exp(1) random numbers.
 ///
@@ -58,8 +58,7 @@ impl Rand for Exp1 {
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{Exp, IndependentSample};
+/// use rand::distributions::{Exp, IndependentSample};
 ///
 /// let exp = Exp::new(2.0);
 /// let v = exp.ind_sample(&mut rand::task_rng());
@@ -91,10 +90,9 @@ impl IndependentSample<f64> for Exp {
 
 #[cfg(test)]
 mod test {
-    use rand::distributions::*;
-    use prelude::*;
-    use rand::*;
-    use super::*;
+    use distributions::{Sample, IndependentSample};
+    use {Rng, task_rng};
+    use super::Exp;
 
     #[test]
     fn test_exp() {
@@ -121,11 +119,10 @@ mod test {
 mod bench {
     extern crate test;
     use self::test::BenchHarness;
-    use mem::size_of;
-    use prelude::*;
-    use rand::{XorShiftRng, RAND_BENCH_N};
-    use super::*;
-    use rand::distributions::*;
+    use std::mem::size_of;
+    use {XorShiftRng, RAND_BENCH_N};
+    use super::Exp;
+    use distributions::Sample;
 
     #[bench]
     fn rand_exp(bh: &mut BenchHarness) {

src/libstd/rand/distributions/gamma.rs renamed to src/librand/distributions/gamma.rs

@@ -10,17 +10,17 @@
 
 //! The Gamma and derived distributions.
 
-use num::Float;
-use num;
-use rand::{Rng, Open01};
+use std::num::Float;
+use std::num;
+use {Rng, Open01};
 use super::normal::StandardNormal;
 use super::{IndependentSample, Sample, Exp};
 
 /// The Gamma distribution `Gamma(shape, scale)` distribution.
 ///
 /// The density function of this distribution is
 ///
-/// ```ignore
+/// ```notrust
 /// f(x) =  x^(k - 1) * exp(-x / θ) / (Γ(k) * θ^k)
 /// ```
 ///
@@ -35,8 +35,7 @@ use super::{IndependentSample, Sample, Exp};
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{IndependentSample, Gamma};
+/// use rand::distributions::{IndependentSample, Gamma};
 ///
 /// let gamma = Gamma::new(2.0, 5.0);
 /// let v = gamma.ind_sample(&mut rand::task_rng());
@@ -179,8 +178,7 @@ impl IndependentSample<f64> for GammaLargeShape {
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{ChiSquared, IndependentSample};
+/// use rand::distributions::{ChiSquared, IndependentSample};
 ///
 /// let chi = ChiSquared::new(11.0);
 /// let v = chi.ind_sample(&mut rand::task_rng());
@@ -231,8 +229,7 @@ impl IndependentSample<f64> for ChiSquared {
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{FisherF, IndependentSample};
+/// use rand::distributions::{FisherF, IndependentSample};
 ///
 /// let f = FisherF::new(2.0, 32.0);
 /// let v = f.ind_sample(&mut rand::task_rng());
@@ -275,8 +272,7 @@ impl IndependentSample<f64> for FisherF {
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{StudentT, IndependentSample};
+/// use rand::distributions::{StudentT, IndependentSample};
 ///
 /// let t = StudentT::new(11.0);
 /// let v = t.ind_sample(&mut rand::task_rng());
@@ -310,10 +306,9 @@ impl IndependentSample<f64> for StudentT {
 
 #[cfg(test)]
 mod test {
-    use rand::distributions::*;
-    use prelude::*;
-    use rand::*;
-    use super::*;
+    use distributions::{Sample, IndependentSample};
+    use {Rng, task_rng};
+    use super::{ChiSquared, StudentT, FisherF};
 
     #[test]
     fn test_chi_squared_one() {
@@ -344,7 +339,7 @@ mod test {
     }
     #[test]
     #[should_fail]
-    fn test_log_normal_invalid_dof() {
+    fn test_chi_squared_invalid_dof() {
         ChiSquared::new(-1.0);
     }
 
@@ -373,11 +368,10 @@ mod test {
 mod bench {
     extern crate test;
     use self::test::BenchHarness;
-    use mem::size_of;
-    use prelude::*;
-    use rand::distributions::IndependentSample;
-    use rand::{StdRng, RAND_BENCH_N};
-    use super::*;
+    use std::mem::size_of;
+    use distributions::IndependentSample;
+    use {StdRng, RAND_BENCH_N};
+    use super::Gamma;
 
 
     #[bench]

src/libstd/rand/distributions/mod.rs renamed to src/librand/distributions/mod.rs

@@ -20,14 +20,9 @@ that do not need to record state.
 
 */
 
-use container::Container;
-use iter::{range, Iterator};
-use option::{Some, None};
-use num;
-use num::CheckedAdd;
-use rand::{Rng, Rand};
-use clone::Clone;
-use vec::MutableVector;
+use std::num;
+use std::num::CheckedAdd;
+use {Rng, Rand};
 
 pub use self::range::Range;
 pub use self::gamma::{Gamma, ChiSquared, FisherF, StudentT};
@@ -94,8 +89,7 @@ pub struct Weighted<T> {
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{Weighted, WeightedChoice, IndependentSample};
+/// use rand::distributions::{Weighted, WeightedChoice, IndependentSample};
 ///
 /// let wc = WeightedChoice::new(~[Weighted { weight: 2, item: 'a' },
 ///                                Weighted { weight: 4, item: 'b' },
@@ -253,9 +247,8 @@ fn ziggurat<R:Rng>(
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
-    use rand::*;
-    use super::*;
+    use {task_rng, Rng, Rand};
+    use super::{RandSample, WeightedChoice, Weighted, Sample, IndependentSample};
 
     #[deriving(Eq, Show)]
     struct ConstRand(uint);

src/libstd/rand/distributions/normal.rs renamed to src/librand/distributions/normal.rs

@@ -10,9 +10,9 @@
 
 //! The normal and derived distributions.
 
-use num::Float;
-use rand::{Rng, Rand, Open01};
-use rand::distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample};
+use std::num::Float;
+use {Rng, Rand, Open01};
+use distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample};
 
 /// A wrapper around an `f64` to generate N(0, 1) random numbers
 /// (a.k.a.  a standard normal, or Gaussian).
@@ -74,8 +74,7 @@ impl Rand for StandardNormal {
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{Normal, IndependentSample};
+/// use rand::distributions::{Normal, IndependentSample};
 ///
 /// // mean 2, standard deviation 3
 /// let normal = Normal::new(2.0, 3.0);
@@ -117,8 +116,7 @@ impl IndependentSample<f64> for Normal {
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{LogNormal, IndependentSample};
+/// use rand::distributions::{LogNormal, IndependentSample};
 ///
 /// // mean 2, standard deviation 3
 /// let log_normal = LogNormal::new(2.0, 3.0);
@@ -148,10 +146,9 @@ impl IndependentSample<f64> for LogNormal {
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
-    use rand::*;
-    use super::*;
-    use rand::distributions::*;
+    use distributions::{Sample, IndependentSample};
+    use {Rng, task_rng};
+    use super::{Normal, LogNormal};
 
     #[test]
     fn test_normal() {
@@ -189,11 +186,10 @@ mod tests {
 mod bench {
     extern crate test;
     use self::test::BenchHarness;
-    use mem::size_of;
-    use prelude::*;
-    use rand::{XorShiftRng, RAND_BENCH_N};
-    use rand::distributions::*;
-    use super::*;
+    use std::mem::size_of;
+    use {XorShiftRng, RAND_BENCH_N};
+    use distributions::{Sample};
+    use super::Normal;
 
     #[bench]
     fn rand_normal(bh: &mut BenchHarness) {

src/libstd/rand/distributions/range.rs renamed to src/librand/distributions/range.rs

@@ -12,10 +12,9 @@
 
 // this is surprisingly complicated to be both generic & correct
 
-use cmp::Ord;
-use num::Bounded;
-use rand::Rng;
-use rand::distributions::{Sample, IndependentSample};
+use std::num::Bounded;
+use Rng;
+use distributions::{Sample, IndependentSample};
 
 /// Sample values uniformly between two bounds.
 ///
@@ -34,8 +33,7 @@ use rand::distributions::{Sample, IndependentSample};
 /// # Example
 ///
 /// ```rust
-/// use std::rand;
-/// use std::rand::distributions::{IndependentSample, Range};
+/// use rand::distributions::{IndependentSample, Range};
 ///
 /// fn main() {
 ///     let between = Range::new(10u, 10000u);
@@ -163,11 +161,10 @@ float_impl! { f64 }
 
 #[cfg(test)]
 mod tests {
-    use prelude::*;
-    use super::*;
-    use rand::*;
-    use rand::distributions::*;
-    use num::Bounded;
+    use distributions::{Sample, IndependentSample};
+    use {Rng, task_rng};
+    use super::Range;
+    use std::num::Bounded;
 
     #[should_fail]
     #[test]

src/libstd/rand/distributions/ziggurat_tables.rs renamed to src/librand/distributions/ziggurat_tables.rs

@@ -10,11 +10,10 @@
 
 //! The ISAAC random number generator.
 
-use rand::{Rng, SeedableRng, OSRng};
-use iter::{Iterator, range, range_step, Repeat};
-use option::{None, Some};
-use vec::{raw, MutableVector, ImmutableVector};
-use mem;
+use {Rng, SeedableRng, OSRng};
+use std::iter::{range_step, Repeat};
+use std::vec::raw;
+use std::mem;
 
 static RAND_SIZE_LEN: u32 = 8;
 static RAND_SIZE: u32 = 1 << RAND_SIZE_LEN;
@@ -430,10 +429,9 @@ impl<'a> SeedableRng<&'a [u64]> for Isaac64Rng {
 
 #[cfg(test)]
 mod test {
-    use super::*;
-    use rand::{Rng, SeedableRng, OSRng};
-    use prelude::*;
-    use vec;
+    use super::{IsaacRng, Isaac64Rng};
+    use {Rng, SeedableRng, OSRng};
+    use std::vec;
 
     #[test]
     fn test_rng_32_rand_seeded() {