Move remaining Rand impls to the Uniform distribution

Author: dhardy

src/distributions/mod.rs

@@ -156,6 +156,14 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 ///   [`StandardNormal`] distributions produce floating point numbers with
 ///   alternative ranges or distributions.)
 ///
+/// The following aggregate types also implement the distribution `Uniform` as
+/// long as their component types implement it:
+///
+/// * Tuples and arrays: Each element of the tuple or array is generated
+///   independently, using the `Uniform` distribution recursively.
+/// * `Option<T>`: Returns `None` with probability 0.5; otherwise generates a
+///   random `T` and returns `Some(T)`.
+///
 /// # Example
 /// ```rust
 /// use rand::{weak_rng, Rng};

src/distributions/other.rs

@@ -38,3 +38,78 @@ impl Distribution<bool> for Uniform {
         rng.gen::<u8>() & 1 == 1
     }
 }
+
+macro_rules! tuple_impl {
+    // use variables to indicate the arity of the tuple
+    ($($tyvar:ident),* ) => {
+        // the trailing commas are for the 1 tuple
+        impl< $( $tyvar ),* >
+            Distribution<( $( $tyvar ),* , )>
+            for Uniform
+            where $( Uniform: Distribution<$tyvar> ),*
+        {
+            #[inline]
+            fn sample<R: Rng>(&self, _rng: &mut R) -> ( $( $tyvar ),* , ) {
+                (
+                    // use the $tyvar's to get the appropriate number of
+                    // repeats (they're not actually needed)
+                    $(
+                        _rng.gen::<$tyvar>()
+                    ),*
+                    ,
+                )
+            }
+        }
+    }
+}
+
+impl Distribution<()> for Uniform {
+    #[inline]
+    fn sample<R: Rng>(&self, _: &mut R) -> () { () }
+}
+tuple_impl!{A}
+tuple_impl!{A, B}
+tuple_impl!{A, B, C}
+tuple_impl!{A, B, C, D}
+tuple_impl!{A, B, C, D, E}
+tuple_impl!{A, B, C, D, E, F}
+tuple_impl!{A, B, C, D, E, F, G}
+tuple_impl!{A, B, C, D, E, F, G, H}
+tuple_impl!{A, B, C, D, E, F, G, H, I}
+tuple_impl!{A, B, C, D, E, F, G, H, I, J}
+tuple_impl!{A, B, C, D, E, F, G, H, I, J, K}
+tuple_impl!{A, B, C, D, E, F, G, H, I, J, K, L}
+
+macro_rules! array_impl {
+    // recursive, given at least one type parameter:
+    {$n:expr, $t:ident, $($ts:ident,)*} => {
+        array_impl!{($n - 1), $($ts,)*}
+
+        impl<T> Distribution<[T; $n]> for Uniform where Uniform: Distribution<T> {
+            #[inline]
+            fn sample<R: Rng>(&self, _rng: &mut R) -> [T; $n] {
+                [_rng.gen::<$t>(), $(_rng.gen::<$ts>()),*]
+            }
+        }
+    };
+    // empty case:
+    {$n:expr,} => {
+        impl<T> Distribution<[T; $n]> for Uniform {
+            fn sample<R: Rng>(&self, _rng: &mut R) -> [T; $n] { [] }
+        }
+    };
+}
+
+array_impl!{32, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T,}
+
+impl<T> Distribution<Option<T>> for Uniform where Uniform: Distribution<T> {
+    #[inline]
+    fn sample<R: Rng>(&self, rng: &mut R) -> Option<T> {
+        // UFCS is needed here: https://github.com/rust-lang/rust/issues/24066
+        if rng.gen::<bool>() {
+            Some(rng.gen())
+        } else {
+            None
+        }
+    }
+}

src/lib.rs

@@ -312,24 +312,13 @@ pub mod isaac {
 // private modules
 mod le;
 mod error;
-mod rand_impls;
 mod prng;
 
 
 /// A type that can be randomly generated using an `Rng`.
-///
-/// ## Built-in Implementations
-///
-/// `Rand` is implemented for any type supporting the [`Uniform`] distribution.
-/// That includes: integers, floating point numbers, char, boolean.
-///
-/// The following aggregate types also implement `Rand` as long as their
-/// component types implement it:
-///
-/// * Tuples and arrays: Each element of the tuple or array is generated
-///   independently, using its own `Rand` implementation.
-/// * `Option<T>`: Returns `None` with probability 0.5; otherwise generates a
-///   random `T` and returns `Some(T)`.
+/// 
+/// This is merely an adaptor around the [`Uniform`] distribution for
+/// convenience and backwards-compatibility.
 /// 
 /// [`Uniform`]: distributions/struct.Uniform.html
 pub trait Rand : Sized {