Implement Distribution for Range(Inclusive)

src/distributions/uniform.rs

@@ -111,6 +111,7 @@
 use std::time::Duration;
 #[cfg(not(feature = "std"))]
 use core::time::Duration;
+use core::ops::{Range, RangeInclusive};
 
 use crate::Rng;
 use crate::distributions::Distribution;
@@ -147,6 +148,9 @@ use packed_simd::*;
 /// `Uniform::new(low, high)`, i.e., excluding `high`. In particular care must
 /// be taken to ensure that rounding never results values `< low` or `>= high`.
 ///
+/// Range expressions like `0..10` can be used as a `Uniform` distribution,
+/// but are less efficient if multiple samples are taken.
+///
 /// # Example
 ///
 /// ```
@@ -278,18 +282,30 @@ pub trait UniformSampler: Sized {
     }
 }
 
-impl<X: SampleUniform> From<::core::ops::Range<X>> for Uniform<X> {
+impl<X: SampleUniform> From<Range<X>> for Uniform<X> {
     fn from(r: ::core::ops::Range<X>) -> Uniform<X> {
         Uniform::new(r.start, r.end)
     }
 }
 
-impl<X: SampleUniform> From<::core::ops::RangeInclusive<X>> for Uniform<X> {
+impl<X: SampleUniform> From<RangeInclusive<X>> for Uniform<X> {
     fn from(r: ::core::ops::RangeInclusive<X>) -> Uniform<X> {
         Uniform::new_inclusive(r.start(), r.end())
     }
 }
 
+impl<T: SampleUniform> Distribution<T> for Range<T> {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T {
+        T::Sampler::sample_single(&self.start, &self.end, rng)
+    }
+}
+
+impl<T: SampleUniform> Distribution<T> for RangeInclusive<T> {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> T {
+        T::Sampler::sample_single_inclusive(self.start(), self.end(), rng)
+    }
+}
+
 /// Helper trait similar to [`Borrow`] but implemented
 /// only for SampleUniform and references to SampleUniform in
 /// order to resolve ambiguity issues.
@@ -1274,6 +1290,17 @@ mod tests {
         assert_eq!(r.inner.scale, 5.0);
     }
 
+    #[test]
+    fn test_std_range_distribution() {
+        let mut rng = crate::test::rng(474);
+        for _ in 0..100 {
+            let x = rng.sample(0..10);
+            assert!(x >= 0 && x < 10);
+            let x = rng.sample(0..=10);
+            assert!(x >= 0 && x <= 10);
+        }
+    }
+
     #[test]
     fn test_uniform_from_std_range_inclusive() {
         let r = Uniform::from(2u32..=6);

src/lib.rs

@@ -227,9 +227,10 @@ pub trait Rng: RngCore {
     /// use rand::distributions::Uniform;
     ///
     /// let mut rng = thread_rng();
-    /// let x = rng.sample(Uniform::new(10u32, 15));
+    /// let x = rng.sample(10u32..15);
     /// // Type annotation requires two types, the type and distribution; the
-    /// // distribution can be inferred.
+    /// // distribution can be inferred. `Uniform` is more efficient than the
+    /// // above range syntax if multiple samples are taken.
     /// let y = rng.sample::<u16, _>(Uniform::new(10, 15));
     /// ```
     fn sample<T, D: Distribution<T>>(&mut self, distr: D) -> T {