Distributions without direct dynamic dispatch

.travis.yml

@@ -7,7 +7,6 @@ matrix:
       script:
         - cargo test
         - cargo build --no-default-features # we cannot exclude doc tests
-        - cargo test --manifest-path rand-derive/Cargo.toml
     - rust: stable
     - rust: stable
       os: osx
@@ -30,7 +29,6 @@ script:
   - cargo test --tests --no-default-features
   - cargo test --features serde-1,log
   - cargo test --tests --no-default-features --features=serde-1
-  - cargo test --manifest-path rand-derive/Cargo.toml
 
 env:
   global:

Cargo.toml

@@ -43,9 +43,6 @@ serde_derive = {version="1", optional=true}
 # see: https://github.com/rust-lang/cargo/issues/1596
 bincode = "0.9"
 
-[workspace]
-members = ["rand-derive"]
-
 [target.'cfg(target_os = "cloudabi")'.dependencies]
 cloudabi = "0.0.3"
 

appveyor.yml

@@ -38,4 +38,3 @@ test_script:
   - cargo test --features nightly
   - cargo test --tests --no-default-features --features=alloc
   - cargo test --tests --no-default-features --features=serde-1
-  - cargo test --manifest-path rand-derive/Cargo.toml

benches/distributions/exponential.rs

@@ -2,12 +2,12 @@ use std::mem::size_of;
 use test::Bencher;
 use rand;
 use rand::distributions::exponential::Exp;
-use rand::distributions::Sample;
+use rand::distributions::Distribution;
 
 #[bench]
 fn rand_exp(b: &mut Bencher) {
     let mut rng = rand::weak_rng();
-    let mut exp = Exp::new(2.71828 * 3.14159);
+    let exp = Exp::new(2.71828 * 3.14159);
 
     b.iter(|| {
         for _ in 0..::RAND_BENCH_N {

benches/distributions/gamma.rs

@@ -1,7 +1,7 @@
 use std::mem::size_of;
 use test::Bencher;
 use rand;
-use rand::distributions::IndependentSample;
+use rand::distributions::Distribution;
 use rand::distributions::gamma::Gamma;
 
 #[bench]
@@ -11,7 +11,7 @@ fn bench_gamma_large_shape(b: &mut Bencher) {
 
     b.iter(|| {
         for _ in 0..::RAND_BENCH_N {
-            gamma.ind_sample(&mut rng);
+            gamma.sample(&mut rng);
         }
     });
     b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;
@@ -24,7 +24,7 @@ fn bench_gamma_small_shape(b: &mut Bencher) {
 
     b.iter(|| {
         for _ in 0..::RAND_BENCH_N {
-            gamma.ind_sample(&mut rng);
+            gamma.sample(&mut rng);
         }
     });
     b.bytes = size_of::<f64>() as u64 * ::RAND_BENCH_N;

benches/distributions/normal.rs

@@ -1,13 +1,13 @@
 use std::mem::size_of;
 use test::Bencher;
 use rand;
-use rand::distributions::Sample;
+use rand::distributions::Distribution;
 use rand::distributions::normal::Normal;
 
 #[bench]
 fn rand_normal(b: &mut Bencher) {
     let mut rng = rand::weak_rng();
-    let mut normal = Normal::new(-2.71828, 3.14159);
+    let normal = Normal::new(-2.71828, 3.14159);
 
     b.iter(|| {
         for _ in 0..::RAND_BENCH_N {

benches/generators.rs

@@ -9,7 +9,7 @@ const BYTES_LEN: usize = 1024;
 use std::mem::size_of;
 use test::{black_box, Bencher};
 
-use rand::{Rng, NewRng, StdRng, OsRng, JitterRng};
+use rand::{Rng, SeedableRng, NewRng, StdRng, OsRng, JitterRng};
 use rand::{XorShiftRng, Hc128Rng, IsaacRng, Isaac64Rng, ChaChaRng};
 
 macro_rules! gen_bytes {
@@ -40,7 +40,7 @@ macro_rules! gen_uint {
     ($fnn:ident, $ty:ty, $gen:ident) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng: $gen = OsRng::new().unwrap().gen();
+            let mut rng = $gen::new().unwrap();
             b.iter(|| {
                 for _ in 0..RAND_BENCH_N {
                     black_box(rng.gen::<$ty>());
@@ -95,9 +95,9 @@ macro_rules! init_gen {
     ($fnn:ident, $gen:ident) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng: XorShiftRng = OsRng::new().unwrap().gen();
+            let mut rng = XorShiftRng::new().unwrap();
             b.iter(|| {
-                let r2: $gen = rng.gen();
+                let r2 = $gen::from_rng(&mut rng).unwrap();
                 black_box(r2);
             });
         }

src/distributions/exponential.rs

@@ -10,10 +10,12 @@
 
 //! The exponential distribution.
 
-use {Rng, Rand};
-use distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample};
+use {Rng};
+use distributions::{ziggurat, ziggurat_tables, Distribution};
 
-/// A wrapper around an `f64` to generate Exp(1) random numbers.
+/// Samples floating-point numbers according to the exponential distribution,
+/// with rate parameter `λ = 1`. This is equivalent to `Exp::new(1.0)` or
+/// sampling with `-rng.gen::<f64>().ln()`, but faster.
 ///
 /// See `Exp` for the general exponential distribution.
 ///
@@ -27,20 +29,20 @@ use distributions::{ziggurat, ziggurat_tables, Sample, IndependentSample};
 /// College, Oxford
 ///
 /// # Example
-///
 /// ```rust
-/// use rand::distributions::exponential::Exp1;
+/// use rand::{weak_rng, Rng};
+/// use rand::distributions::Exp1;
 ///
-/// let Exp1(x) = rand::random();
-/// println!("{}", x);
+/// let val: f64 = weak_rng().sample(Exp1);
+/// println!("{}", val);
 /// ```
 #[derive(Clone, Copy, Debug)]
-pub struct Exp1(pub f64);
+pub struct Exp1;
 
 // This could be done via `-rng.gen::<f64>().ln()` but that is slower.
-impl Rand for Exp1 {
+impl Distribution<f64> for Exp1 {
     #[inline]
-    fn rand<R:Rng>(rng: &mut R) -> Exp1 {
+    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
         #[inline]
         fn pdf(x: f64) -> f64 {
             (-x).exp()
@@ -50,10 +52,10 @@ impl Rand for Exp1 {
             ziggurat_tables::ZIG_EXP_R - rng.gen::<f64>().ln()
         }
 
-        Exp1(ziggurat(rng, false,
-                      &ziggurat_tables::ZIG_EXP_X,
-                      &ziggurat_tables::ZIG_EXP_F,
-                      pdf, zero_case))
+        ziggurat(rng, false,
+                 &ziggurat_tables::ZIG_EXP_X,
+                 &ziggurat_tables::ZIG_EXP_F,
+                 pdf, zero_case)
     }
 }
 
@@ -65,10 +67,10 @@ impl Rand for Exp1 {
 /// # Example
 ///
 /// ```rust
-/// use rand::distributions::{Exp, IndependentSample};
+/// use rand::distributions::{Exp, Distribution};
 ///
 /// let exp = Exp::new(2.0);
-/// let v = exp.ind_sample(&mut rand::thread_rng());
+/// let v = exp.sample(&mut rand::thread_rng());
 /// println!("{} is from a Exp(2) distribution", v);
 /// ```
 #[derive(Clone, Copy, Debug)]
@@ -87,28 +89,25 @@ impl Exp {
     }
 }
 
-impl Sample<f64> for Exp {
-    fn sample<R: Rng>(&mut self, rng: &mut R) -> f64 { self.ind_sample(rng) }
-}
-impl IndependentSample<f64> for Exp {
-    fn ind_sample<R: Rng>(&self, rng: &mut R) -> f64 {
-        let Exp1(n) = rng.gen::<Exp1>();
+impl Distribution<f64> for Exp {
+    fn sample<R: Rng>(&self, rng: &mut R) -> f64 {
+        let n: f64 = rng.sample(Exp1);
         n * self.lambda_inverse
     }
 }
 
 #[cfg(test)]
 mod test {
-    use distributions::{Sample, IndependentSample};
+    use distributions::Distribution;
     use super::Exp;
 
     #[test]
     fn test_exp() {
-        let mut exp = Exp::new(10.0);
+        let exp = Exp::new(10.0);
         let mut rng = ::test::rng(221);
         for _ in 0..1000 {
             assert!(exp.sample(&mut rng) >= 0.0);
-            assert!(exp.ind_sample(&mut rng) >= 0.0);
+            assert!(exp.sample(&mut rng) >= 0.0);
         }
     }
     #[test]