diff --git a/CHANGELOG.md b/CHANGELOG.md
index 83e0008e57e..12afe544d25 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -80,16 +80,16 @@ You may also find the [Update Guide](UPDATING.md) useful.
 ### Distributions
 - New `Distribution` trait. (#256)
 - Deprecate `Rand`, `Sample` and `IndependentSample` traits. (#256)
-- Add a `Uniform` distribution (replaces most `Rand` implementations). (#256)
+- Add a `Standard` distribution (replaces most `Rand` implementations). (#256)
 - Add `Binomial` and `Poisson` distributions. (#96)
 - Add `Alphanumeric` distribution. (#279)
-- Remove `Open01` and `Closed01` distributions, use `Uniform` instead (open distribution). (#274)
+- Remove `Open01` and `Closed01` distributions, use `Standard` instead (open distribution). (#274)
 - Rework `Range` type, making it possible to implement it for user types. (#274)
 - Add `Range::new_inclusive` for inclusive ranges. (#274)
 - Add `Range::sample_single` to allow for optimized implementations. (#274)
 - Use widening multiply method for much faster integer range reduction. (#274)
-- `Uniform` distributions for `bool` uses `Range`. (#274)
-- `Uniform` distributions for `bool` uses sign test. (#274)
+- `Standard` distributions for `bool` uses `Range`. (#274)
+- `Standard` distributions for `bool` uses sign test. (#274)
 
 
 ## [0.4.2] - 2018-01-06
diff --git a/README.md b/README.md
index 312d2a5cc5a..6947494a261 100644
--- a/README.md
+++ b/README.md
@@ -84,7 +84,8 @@ The `rand` crate provides:
 -   pseudo-random number generators: `StdRng`, `SmallRng`, `prng` module
 -   convenient, auto-seeded crypto-grade thread-local generator: `thread_rng`
 -   `distributions` producing many different types of random values:
-    -   `Uniform`-ly distributed integers and floats of many types
+    -   a `Standard` distribution for integers, floats,and derived types
+        including tuples, arrays and `Option`
     -   unbiased sampling from specified `Range`s
     -   sampling from exponential/normal/gamma distributions
     -   sampling from binomial/poisson distributions
diff --git a/UPDATING.md b/UPDATING.md
index 4d53823a364..2f3b0b3cc06 100644
--- a/UPDATING.md
+++ b/UPDATING.md
@@ -198,8 +198,8 @@ cryptographic generator, used by `StdRng` and `thread_rng()`.
 ### Helper functions/traits
 
 The `Rand` trait has been deprecated. Instead, users are encouraged to use
-`Uniform` which is a real distribution and supports the same sampling as `Rand`.
-`Rng::gen()` now uses `Uniform` and should work exactly as before.
+`Standard` which is a real distribution and supports the same sampling as
+ `Rand`.`Rng::gen()` now uses `Standard` and should work exactly as before.
 
 The `random()` function has been removed; users may simply use
 `thread_rng().gen()` instead or may choose to cache
@@ -221,18 +221,18 @@ removed in a future release.
 `Distribution::sample` (as well as several other functions) can now be called
 directly on type-erased (unsized) RNGs.
 
-`RandSample` has been removed (see `Rand` deprecation and new `Uniform`
+`RandSample` has been removed (see `Rand` deprecation and new `Standard`
 distribution).
 
 The `Open01` and `Closed01` wrappers have been removed. `Rng::gen()` (via
-`Uniform`) now yields samples from `(0, 1)` for floats; i.e. the same as the old
-`Open01`. This is considered sufficient for most uses.
+`Standard`) now yields samples from `(0, 1)` for floats; i.e. the same as the
+old `Open01`. This is considered sufficient for most uses.
 
 #### Uniform distributions
 
 Two new distributions are available:
 
--   `Uniform` produces uniformly-distributed samples for many different types,
+-   `Standard` produces uniformly-distributed samples for many different types,
     and acts as a replacement for `Rand`
 -   `Alphanumeric` samples `char`s from the ranges `a-z A-Z 0-9`
 
diff --git a/benches/distributions.rs b/benches/distributions.rs
index e5e85bb488f..6d15aeb3f26 100644
--- a/benches/distributions.rs
+++ b/benches/distributions.rs
@@ -82,19 +82,19 @@ distr_float!(distr_range_f32, f32, Range::new(2.26f32, 2.319));
 distr_float!(distr_range_f64, f64, Range::new(2.26f64, 2.319));
 
 // uniform
-distr_int!(distr_uniform_i8, i8, Uniform);
-distr_int!(distr_uniform_i16, i16, Uniform);
-distr_int!(distr_uniform_i32, i32, Uniform);
-distr_int!(distr_uniform_i64, i64, Uniform);
+distr_int!(distr_uniform_i8, i8, Standard);
+distr_int!(distr_uniform_i16, i16, Standard);
+distr_int!(distr_uniform_i32, i32, Standard);
+distr_int!(distr_uniform_i64, i64, Standard);
 #[cfg(feature = "i128_support")]
-distr_int!(distr_uniform_i128, i128, Uniform);
+distr_int!(distr_uniform_i128, i128, Standard);
 
-distr!(distr_uniform_bool, bool, Uniform);
+distr!(distr_uniform_bool, bool, Standard);
 distr!(distr_uniform_alphanumeric, char, Alphanumeric);
-distr!(distr_uniform_codepoint, char, Uniform);
+distr!(distr_uniform_codepoint, char, Standard);
 
-distr_float!(distr_uniform_f32, f32, Uniform);
-distr_float!(distr_uniform_f64, f64, Uniform);
+distr_float!(distr_uniform_f32, f32, Standard);
+distr_float!(distr_uniform_f64, f64, Standard);
 
 // distributions
 distr_float!(distr_exp, f64, Exp::new(1.23 * 4.56));
diff --git a/benches/misc.rs b/benches/misc.rs
index 5d4cee53719..258f082cdf3 100644
--- a/benches/misc.rs
+++ b/benches/misc.rs
@@ -113,10 +113,10 @@ fn gen_1k_gen_iter(b: &mut Bencher) {
 
 #[bench]
 fn gen_1k_sample_iter(b: &mut Bencher) {
-    use rand::distributions::{Distribution, Uniform};
+    use rand::distributions::{Distribution, Standard};
     let mut rng = SmallRng::from_rng(&mut thread_rng()).unwrap();
     b.iter(|| {
-        let v: Vec<u64> = Uniform.sample_iter(&mut rng).take(128).collect();
+        let v: Vec<u64> = Standard.sample_iter(&mut rng).take(128).collect();
         black_box(v);
     });
     b.bytes = 1024;
diff --git a/src/distributions/float.rs b/src/distributions/float.rs
index d3a13ddb158..b1b76852fcd 100644
--- a/src/distributions/float.rs
+++ b/src/distributions/float.rs
@@ -12,7 +12,7 @@
 
 use core::mem;
 use Rng;
-use distributions::{Distribution, Uniform};
+use distributions::{Distribution, Standard};
 
 pub(crate) trait IntoFloat {
     type F;
@@ -42,7 +42,7 @@ macro_rules! float_impls {
             }
         }
 
-        impl Distribution<$ty> for Uniform {
+        impl Distribution<$ty> for Standard {
             /// Generate a floating point number in the open interval `(0, 1)`
             /// (not including either endpoint) with a uniform distribution.
             fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
diff --git a/src/distributions/gamma.rs b/src/distributions/gamma.rs
index e96670925bd..4d68e57ed4a 100644
--- a/src/distributions/gamma.rs
+++ b/src/distributions/gamma.rs
@@ -13,9 +13,9 @@
 use self::GammaRepr::*;
 use self::ChiSquaredRepr::*;
 
-use {Rng};
+use Rng;
 use distributions::normal::StandardNormal;
-use distributions::{Distribution, Exp, Uniform};
+use distributions::{Distribution, Exp};
 
 /// The Gamma distribution `Gamma(shape, scale)` distribution.
 ///
@@ -142,7 +142,7 @@ impl Distribution<f64> for Gamma {
 }
 impl Distribution<f64> for GammaSmallShape {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> f64 {
-        let u: f64 = rng.sample(Uniform);
+        let u: f64 = rng.gen();
 
         self.large_shape.sample(rng) * u.powf(self.inv_shape)
     }
@@ -157,7 +157,7 @@ impl Distribution<f64> for GammaLargeShape {
             }
 
             let v = v_cbrt * v_cbrt * v_cbrt;
-            let u: f64 = rng.sample(Uniform);
+            let u: f64 = rng.gen();
 
             let x_sqr = x * x;
             if u < 1.0 - 0.0331 * x_sqr * x_sqr ||
diff --git a/src/distributions/integer.rs b/src/distributions/integer.rs
index 93c2f97d742..04bf16637ac 100644
--- a/src/distributions/integer.rs
+++ b/src/distributions/integer.rs
@@ -8,40 +8,40 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The implementations of the `Uniform` distribution for integer types.
+//! The implementations of the `Standard` distribution for integer types.
 
 use {Rng};
-use distributions::{Distribution, Uniform};
+use distributions::{Distribution, Standard};
 
-impl Distribution<isize> for Uniform {
+impl Distribution<isize> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> isize {
         rng.gen::<usize>() as isize
     }
 }
 
-impl Distribution<i8> for Uniform {
+impl Distribution<i8> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i8 {
         rng.next_u32() as i8
     }
 }
 
-impl Distribution<i16> for Uniform {
+impl Distribution<i16> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i16 {
         rng.next_u32() as i16
     }
 }
 
-impl Distribution<i32> for Uniform {
+impl Distribution<i32> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i32 {
         rng.next_u32() as i32
     }
 }
 
-impl Distribution<i64> for Uniform {
+impl Distribution<i64> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i64 {
         rng.next_u64() as i64
@@ -49,14 +49,14 @@ impl Distribution<i64> for Uniform {
 }
 
 #[cfg(feature = "i128_support")]
-impl Distribution<i128> for Uniform {
+impl Distribution<i128> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> i128 {
         rng.gen::<u128>() as i128
     }
 }
 
-impl Distribution<usize> for Uniform {
+impl Distribution<usize> for Standard {
     #[inline]
     #[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> usize {
@@ -70,28 +70,28 @@ impl Distribution<usize> for Uniform {
     }
 }
 
-impl Distribution<u8> for Uniform {
+impl Distribution<u8> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
         rng.next_u32() as u8
     }
 }
 
-impl Distribution<u16> for Uniform {
+impl Distribution<u16> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {
         rng.next_u32() as u16
     }
 }
 
-impl Distribution<u32> for Uniform {
+impl Distribution<u32> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {
         rng.next_u32()
     }
 }
 
-impl Distribution<u64> for Uniform {
+impl Distribution<u64> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
         rng.next_u64()
@@ -99,7 +99,7 @@ impl Distribution<u64> for Uniform {
 }
 
 #[cfg(feature = "i128_support")]
-impl Distribution<u128> for Uniform {
+impl Distribution<u128> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
         // Use LE; we explicitly generate one value before the next.
@@ -113,26 +113,26 @@ impl Distribution<u128> for Uniform {
 #[cfg(test)]
 mod tests {
     use Rng;
-    use distributions::{Uniform};
+    use distributions::{Standard};
     
     #[test]
     fn test_integers() {
         let mut rng = ::test::rng(806);
         
-        rng.sample::<isize, _>(Uniform);
-        rng.sample::<i8, _>(Uniform);
-        rng.sample::<i16, _>(Uniform);
-        rng.sample::<i32, _>(Uniform);
-        rng.sample::<i64, _>(Uniform);
+        rng.sample::<isize, _>(Standard);
+        rng.sample::<i8, _>(Standard);
+        rng.sample::<i16, _>(Standard);
+        rng.sample::<i32, _>(Standard);
+        rng.sample::<i64, _>(Standard);
         #[cfg(feature = "i128_support")]
-        rng.sample::<i128, _>(Uniform);
+        rng.sample::<i128, _>(Standard);
         
-        rng.sample::<usize, _>(Uniform);
-        rng.sample::<u8, _>(Uniform);
-        rng.sample::<u16, _>(Uniform);
-        rng.sample::<u32, _>(Uniform);
-        rng.sample::<u64, _>(Uniform);
+        rng.sample::<usize, _>(Standard);
+        rng.sample::<u8, _>(Standard);
+        rng.sample::<u16, _>(Standard);
+        rng.sample::<u32, _>(Standard);
+        rng.sample::<u64, _>(Standard);
         #[cfg(feature = "i128_support")]
-        rng.sample::<u128, _>(Uniform);
+        rng.sample::<u128, _>(Standard);
     }
 }
diff --git a/src/distributions/mod.rs b/src/distributions/mod.rs
index 768bbc3c359..6afbf923709 100644
--- a/src/distributions/mod.rs
+++ b/src/distributions/mod.rs
@@ -140,12 +140,12 @@ pub trait Distribution<T> {
     ///
     /// ```rust
     /// use rand::thread_rng;
-    /// use rand::distributions::{Distribution, Alphanumeric, Range, Uniform};
+    /// use rand::distributions::{Distribution, Alphanumeric, Range, Standard};
     ///
     /// let mut rng = thread_rng();
     ///
     /// // Vec of 16 x f32:
-    /// let v: Vec<f32> = Uniform.sample_iter(&mut rng).take(16).collect();
+    /// let v: Vec<f32> = Standard.sample_iter(&mut rng).take(16).collect();
     ///
     /// // String:
     /// let s: String = Alphanumeric.sample_iter(&mut rng).take(7).collect();
@@ -208,7 +208,7 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 ///
 /// ## Built-in Implementations
 ///
-/// This crate implements the distribution `Uniform` for various primitive
+/// This crate implements the distribution `Standard` for various primitive
 /// types.  Assuming the provided `Rng` is well-behaved, these implementations
 /// generate values with the following ranges and distributions:
 ///
@@ -222,20 +222,20 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 /// * Floating point types (`f32` and `f64`): Uniformly distributed in the
 ///   open range `(0, 1)`.
 ///
-/// The following aggregate types also implement the distribution `Uniform` as
+/// The following aggregate types also implement the distribution `Standard` 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.
+///   independently, using the `Standard` distribution recursively.
 /// * `Option<T>`: Returns `None` with probability 0.5; otherwise generates a
 ///   random `T` and returns `Some(T)`.
 ///
 /// # Example
 /// ```rust
 /// use rand::{NewRng, SmallRng, Rng};
-/// use rand::distributions::Uniform;
+/// use rand::distributions::Standard;
 ///
-/// let val: f32 = SmallRng::new().sample(Uniform);
+/// let val: f32 = SmallRng::new().sample(Standard);
 /// println!("f32 from (0,1): {}", val);
 /// ```
 ///
@@ -243,11 +243,11 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 /// 
 /// ```rust
 /// use rand::{thread_rng, Rng, RngCore};
-/// use rand::distributions::Uniform;
+/// use rand::distributions::Standard;
 ///
 /// let mut rng = thread_rng();
 /// let erased_rng: &mut RngCore = &mut rng;
-/// let val: f32 = erased_rng.sample(Uniform);
+/// let val: f32 = erased_rng.sample(Standard);
 /// println!("f32 from (0,1): {}", val);
 /// ```
 ///
@@ -274,12 +274,12 @@ impl<'a, T, D: Distribution<T>> Distribution<T> for &'a D {
 /// [`Exp1`]: struct.Exp1.html
 /// [`StandardNormal`]: struct.StandardNormal.html
 #[derive(Debug)]
-pub struct Uniform;
+pub struct Standard;
 
 #[allow(deprecated)]
-impl<T> ::Rand for T where Uniform: Distribution<T> {
+impl<T> ::Rand for T where Standard: Distribution<T> {
     fn rand<R: Rng>(rng: &mut R) -> Self {
-        Uniform.sample(rng)
+        Standard.sample(rng)
     }
 }
 
diff --git a/src/distributions/normal.rs b/src/distributions/normal.rs
index e101c390c7e..f403f020488 100644
--- a/src/distributions/normal.rs
+++ b/src/distributions/normal.rs
@@ -10,8 +10,8 @@
 
 //! The normal and derived distributions.
 
-use {Rng};
-use distributions::{ziggurat, ziggurat_tables, Distribution, Uniform};
+use Rng;
+use distributions::{ziggurat, ziggurat_tables, Distribution};
 
 /// Samples floating-point numbers according to the normal distribution
 /// `N(0, 1)` (a.k.a.  a standard normal, or Gaussian). This is equivalent to
@@ -55,8 +55,8 @@ impl Distribution<f64> for StandardNormal {
             let mut y = 0.0f64;
 
             while -2.0 * y < x * x {
-                let x_: f64 = rng.sample(Uniform);
-                let y_: f64 = rng.sample(Uniform);
+                let x_: f64 = rng.gen();
+                let y_: f64 = rng.gen();
 
                 x = x_.ln() / ziggurat_tables::ZIG_NORM_R;
                 y = y_.ln();
diff --git a/src/distributions/other.rs b/src/distributions/other.rs
index fd3ccaa1298..e672e39e4cf 100644
--- a/src/distributions/other.rs
+++ b/src/distributions/other.rs
@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! The implementations of the `Uniform` distribution for other built-in types.
+//! The implementations of the `Standard` distribution for other built-in types.
 
 use core::char;
 
 use {Rng};
-use distributions::{Distribution, Uniform, Range};
+use distributions::{Distribution, Standard, Range};
 
 // ----- Sampling distributions -----
 
@@ -40,7 +40,7 @@ pub struct Alphanumeric;
 
 // ----- Implementations of distributions -----
 
-impl Distribution<char> for Uniform {
+impl Distribution<char> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> char {
         let range = Range::new(0u32, 0x11_0000);
@@ -75,7 +75,7 @@ impl Distribution<char> for Alphanumeric {
     }
 }
 
-impl Distribution<bool> for Uniform {
+impl Distribution<bool> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> bool {
         // We can compare against an arbitrary bit of an u32 to get a bool.
@@ -92,8 +92,8 @@ macro_rules! tuple_impl {
         // the trailing commas are for the 1 tuple
         impl< $( $tyvar ),* >
             Distribution<( $( $tyvar ),* , )>
-            for Uniform
-            where $( Uniform: Distribution<$tyvar> ),*
+            for Standard
+            where $( Standard: Distribution<$tyvar> ),*
         {
             #[inline]
             fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> ( $( $tyvar ),* , ) {
@@ -110,7 +110,7 @@ macro_rules! tuple_impl {
     }
 }
 
-impl Distribution<()> for Uniform {
+impl Distribution<()> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, _: &mut R) -> () { () }
 }
@@ -132,7 +132,7 @@ macro_rules! array_impl {
     {$n:expr, $t:ident, $($ts:ident,)*} => {
         array_impl!{($n - 1), $($ts,)*}
 
-        impl<T> Distribution<[T; $n]> for Uniform where Uniform: Distribution<T> {
+        impl<T> Distribution<[T; $n]> for Standard where Standard: Distribution<T> {
             #[inline]
             fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> [T; $n] {
                 [_rng.gen::<$t>(), $(_rng.gen::<$ts>()),*]
@@ -141,7 +141,7 @@ macro_rules! array_impl {
     };
     // empty case:
     {$n:expr,} => {
-        impl<T> Distribution<[T; $n]> for Uniform {
+        impl<T> Distribution<[T; $n]> for Standard {
             fn sample<R: Rng + ?Sized>(&self, _rng: &mut R) -> [T; $n] { [] }
         }
     };
@@ -149,7 +149,7 @@ macro_rules! array_impl {
 
 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> {
+impl<T> Distribution<Option<T>> for Standard where Standard: Distribution<T> {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Option<T> {
         // UFCS is needed here: https://github.com/rust-lang/rust/issues/24066
@@ -164,7 +164,7 @@ impl<T> Distribution<Option<T>> for Uniform where Uniform: Distribution<T> {
 
 #[cfg(test)]
 mod tests {
-    use {Rng, RngCore, Uniform};
+    use {Rng, RngCore, Standard};
     use distributions::Alphanumeric;
     #[cfg(all(not(feature="std"), feature="alloc"))] use alloc::String;
 
@@ -172,8 +172,8 @@ mod tests {
     fn test_misc() {
         let rng: &mut RngCore = &mut ::test::rng(820);
         
-        rng.sample::<char, _>(Uniform);
-        rng.sample::<bool, _>(Uniform);
+        rng.sample::<char, _>(Standard);
+        rng.sample::<bool, _>(Standard);
     }
     
     #[cfg(feature="alloc")]
diff --git a/src/distributions/range.rs b/src/distributions/range.rs
index 7f32f482020..c36abdd21b2 100644
--- a/src/distributions/range.rs
+++ b/src/distributions/range.rs
@@ -11,7 +11,7 @@
 //! A distribution generating numbers within a given range.
 
 use Rng;
-use distributions::{Distribution, Uniform};
+use distributions::Distribution;
 use distributions::float::IntoFloat;
 
 /// Sample values uniformly between two bounds.
@@ -274,7 +274,7 @@ macro_rules! range_int_impl {
                     // casting is a no-op.
                     let zone = self.zone as $signed as $i_large as $u_large;
                     loop {
-                        let v: $u_large = Uniform.sample(rng);
+                        let v: $u_large = rng.gen();
                         let (hi, lo) = v.wmul(range);
                         if lo <= zone {
                             return self.low.wrapping_add(hi as $ty);
@@ -282,7 +282,7 @@ macro_rules! range_int_impl {
                     }
                 } else {
                     // Sample from the entire integer range.
-                    Uniform.sample(rng)
+                    rng.gen()
                 }
             }
 
@@ -306,7 +306,7 @@ macro_rules! range_int_impl {
                     };
 
                 loop {
-                    let v: $u_large = Uniform.sample(rng);
+                    let v: $u_large = rng.gen();
                     let (hi, lo) = v.wmul(range);
                     if lo <= zone {
                         return low.wrapping_add(hi as $ty);
diff --git a/src/lib.rs b/src/lib.rs
index c3f7997dea7..76ef632ff76 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -26,7 +26,7 @@
 //! ```
 //!
 //! The key function is [`Rng::gen()`]. It is polymorphic and so can be used to
-//! generate many types; the [`Uniform`] distribution carries the
+//! generate many types; the [`Standard`] distribution carries the
 //! implementations. In some cases type annotation is required, e.g.
 //! `rng.gen::<f64>()`.
 //!
@@ -176,7 +176,7 @@
 //! [`Isaac64Rng`]: prng/isaac64/struct.Isaac64Rng.html
 //! [`seq`]: seq/index.html
 //! [`distributions`]: distributions/index.html
-//! [`Uniform`]: distributions/struct.Uniform.html
+//! [`Standard`]: distributions/struct.Standard.html
 
 #![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk.png",
        html_favicon_url = "https://www.rust-lang.org/favicon.ico",
@@ -256,19 +256,19 @@ mod reseeding;
 
 // Normal imports just for this file
 use core::{marker, mem, slice};
-use distributions::{Distribution, Uniform, Range};
+use distributions::{Distribution, Standard, Range};
 use distributions::range::SampleRange;
 use prng::hc128::Hc128Rng;
 
 
 /// A type that can be randomly generated using an [`Rng`].
 /// 
-/// This is merely an adaptor around the [`Uniform`] distribution for
+/// This is merely an adaptor around the [`Standard`] distribution for
 /// convenience and backwards-compatibility.
 /// 
 /// [`Rng`]: trait.Rng.html
-/// [`Uniform`]: distributions/struct.Uniform.html
-#[deprecated(since="0.5.0", note="replaced by distributions::Uniform")]
+/// [`Standard`]: distributions/struct.Standard.html
+#[deprecated(since="0.5.0", note="replaced by distributions::Standard")]
 pub trait Rand : Sized {
     /// Generates a random instance of this type using the specified source of
     /// randomness.
@@ -315,9 +315,9 @@ pub trait Rand : Sized {
 /// 
 /// [`RngCore`]: trait.RngCore.html
 pub trait Rng: RngCore {
-    /// Return a random value supporting the [`Uniform`] distribution.
+    /// Return a random value supporting the [`Standard`] distribution.
     ///
-    /// [`Uniform`]: distributions/struct.Uniform.html
+    /// [`Standard`]: distributions/struct.Standard.html
     ///
     /// # Example
     ///
@@ -330,8 +330,8 @@ pub trait Rng: RngCore {
     /// println!("{:?}", rng.gen::<(f64, bool)>());
     /// ```
     #[inline(always)]
-    fn gen<T>(&mut self) -> T where Uniform: Distribution<T> {
-        Uniform.sample(self)
+    fn gen<T>(&mut self) -> T where Standard: Distribution<T> {
+        Standard.sample(self)
     }
 
     /// Generate a random value in the range [`low`, `high`), i.e. inclusive of
@@ -383,18 +383,18 @@ pub trait Rng: RngCore {
     ///
     /// ```rust
     /// use rand::{thread_rng, Rng};
-    /// use rand::distributions::{Alphanumeric, Range, Uniform};
+    /// use rand::distributions::{Alphanumeric, Range, Standard};
     ///
     /// let mut rng = thread_rng();
     ///
     /// // Vec of 16 x f32:
-    /// let v: Vec<f32> = thread_rng().sample_iter(&Uniform).take(16).collect();
+    /// let v: Vec<f32> = thread_rng().sample_iter(&Standard).take(16).collect();
     ///
     /// // String:
     /// let s: String = rng.sample_iter(&Alphanumeric).take(7).collect();
     ///
     /// // Combined values
-    /// println!("{:?}", thread_rng().sample_iter(&Uniform).take(5)
+    /// println!("{:?}", thread_rng().sample_iter(&Standard).take(5)
     ///                              .collect::<Vec<(f64, bool)>>());
     ///
     /// // Dice-rolling:
@@ -580,8 +580,8 @@ pub trait Rng: RngCore {
     ///                     .collect::<Vec<(f64, bool)>>());
     /// ```
     #[allow(deprecated)]
-    #[deprecated(since="0.5.0", note="use Rng::sample_iter(&Uniform) instead")]
-    fn gen_iter<T>(&mut self) -> Generator<T, &mut Self> where Uniform: Distribution<T> {
+    #[deprecated(since="0.5.0", note="use Rng::sample_iter(&Standard) instead")]
+    fn gen_iter<T>(&mut self) -> Generator<T, &mut Self> where Standard: Distribution<T> {
         Generator { rng: self, _marker: marker::PhantomData }
     }
 
@@ -732,7 +732,7 @@ pub struct Generator<T, R: RngCore> {
 }
 
 #[allow(deprecated)]
-impl<T, R: RngCore> Iterator for Generator<T, R> where Uniform: Distribution<T> {
+impl<T, R: RngCore> Iterator for Generator<T, R> where Standard: Distribution<T> {
     type Item = T;
 
     fn next(&mut self) -> Option<T> {
@@ -1170,7 +1170,7 @@ mod test {
 
     #[test]
     fn test_rng_trait_object() {
-        use distributions::{Distribution, Uniform};
+        use distributions::{Distribution, Standard};
         let mut rng = rng(109);
         let mut r = &mut rng as &mut RngCore;
         r.next_u32();
@@ -1180,13 +1180,13 @@ mod test {
         let b: &[_] = &[1, 1, 1];
         assert_eq!(v, b);
         assert_eq!(r.gen_range(0, 1), 0);
-        let _c: u8 = Uniform.sample(&mut r);
+        let _c: u8 = Standard.sample(&mut r);
     }
 
     #[test]
     #[cfg(feature="alloc")]
     fn test_rng_boxed_trait() {
-        use distributions::{Distribution, Uniform};
+        use distributions::{Distribution, Standard};
         let rng = rng(110);
         let mut r = Box::new(rng) as Box<RngCore>;
         r.next_u32();
@@ -1196,7 +1196,7 @@ mod test {
         let b: &[_] = &[1, 1, 1];
         assert_eq!(v, b);
         assert_eq!(r.gen_range(0, 1), 0);
-        let _c: u8 = Uniform.sample(&mut r);
+        let _c: u8 = Standard.sample(&mut r);
     }
 
     #[test]
diff --git a/src/prng/isaac.rs b/src/prng/isaac.rs
index ba529014752..6193277db15 100644
--- a/src/prng/isaac.rs
+++ b/src/prng/isaac.rs
@@ -84,7 +84,7 @@ const RAND_SIZE: usize = 1 << RAND_SIZE_LEN;
 /// [3]: Jean-Philippe Aumasson, [*On the pseudo-random generator ISAAC*](
 ///      https://eprint.iacr.org/2006/438)
 ///
-/// [`Hc128Rng`]: prng/hc128/struct.Hc128Rng.html
+/// [`Hc128Rng`]: hc128/struct.Hc128Rng.html
 #[cfg_attr(feature="serde-1", derive(Serialize,Deserialize))]
 pub struct IsaacRng {
     #[cfg_attr(feature="serde-1",serde(with="super::isaac_serde::rand_size_serde"))]
diff --git a/src/prng/isaac64.rs b/src/prng/isaac64.rs
index c62d8185fb5..65dedac3894 100644
--- a/src/prng/isaac64.rs
+++ b/src/prng/isaac64.rs
@@ -73,8 +73,8 @@ const RAND_SIZE: usize = 1 << RAND_SIZE_LEN;
 /// [1]: Bob Jenkins, [*ISAAC and RC4*](
 ///      http://burtleburtle.net/bob/rand/isaac.html)
 ///
-/// [`IsaacRng`]: prng/isaac/struct.IsaacRng.html
-/// [`Hc128Rng`]: prng/hc128/struct.Hc128Rng.html
+/// [`IsaacRng`]: ../isaac/struct.IsaacRng.html
+/// [`Hc128Rng`]: hc128/struct.Hc128Rng.html
 #[cfg_attr(feature="serde-1", derive(Serialize,Deserialize))]
 pub struct Isaac64Rng {
     #[cfg_attr(feature="serde-1",serde(with="super::isaac_serde::rand_size_serde"))]
diff --git a/src/thread_rng.rs b/src/thread_rng.rs
index c849a3bbf7f..1b93a8c2107 100644
--- a/src/thread_rng.rs
+++ b/src/thread_rng.rs
@@ -15,7 +15,7 @@ use std::rc::Rc;
 
 use {RngCore, CryptoRng, SeedableRng, EntropyRng};
 use prng::hc128::Hc128Core;
-use {Distribution, Uniform, Rng, Error};
+use {Distribution, Standard, Rng, Error};
 use reseeding::ReseedingRng;
 
 // Rationale for using `UnsafeCell` in `ThreadRng`:
@@ -169,7 +169,7 @@ impl CryptoRng for ThreadRng {}
 /// [`Rand`]: trait.Rand.html
 #[deprecated(since="0.5.0", note="removed in favor of thread_rng().gen()")]
 #[inline]
-pub fn random<T>() -> T where Uniform: Distribution<T> {
+pub fn random<T>() -> T where Standard: Distribution<T> {
     thread_rng().gen()
 }