Add prelude module

Author: dhardy

benches/generators.rs

@@ -9,14 +9,11 @@ const BYTES_LEN: usize = 1024;
 use std::mem::size_of;
 use test::{black_box, Bencher};
 
-use rand::{RngCore, Rng, SeedableRng, FromEntropy};
-use rand::entropy::{OsRng, EntropyRng};
-use rand::entropy::jitter::JitterRng;
+use rand::prelude::*;
+use rand::entropy::{OsRng, EntropyRng, jitter::JitterRng};
 use rand::prng::{XorShiftRng, Hc128Rng, IsaacRng, Isaac64Rng, ChaChaRng};
 use rand::prng::hc128::Hc128Core;
 use rand::reseeding::ReseedingRng;
-use rand::rngs::{StdRng, SmallRng};
-use rand::thread_rng;
 
 macro_rules! gen_bytes {
     ($fnn:ident, $gen:expr) => {

benches/misc.rs

@@ -7,8 +7,7 @@ const RAND_BENCH_N: u64 = 1000;
 
 use test::{black_box, Bencher};
 
-use rand::{SeedableRng, Rng, thread_rng};
-use rand::rngs::SmallRng;
+use rand::prelude::*;
 use rand::seq::*;
 
 #[bench]

src/distributions/exponential.rs

@@ -30,8 +30,7 @@ use distributions::{ziggurat, ziggurat_tables, Distribution};
 ///
 /// # Example
 /// ```rust
-/// use rand::{FromEntropy, Rng};
-/// use rand::rngs::SmallRng;
+/// use rand::prelude::*;
 /// use rand::distributions::Exp1;
 ///
 /// let val: f64 = SmallRng::from_entropy().sample(Exp1);

src/distributions/mod.rs

@@ -400,8 +400,7 @@ impl<'a, D, R, T> Iterator for DistIter<'a, D, R, T>
 ///
 /// # Example
 /// ```
-/// use rand::{FromEntropy, Rng};
-/// use rand::rngs::SmallRng;
+/// use rand::prelude::*;
 /// use rand::distributions::Standard;
 ///
 /// let val: f32 = SmallRng::from_entropy().sample(Standard);

src/distributions/normal.rs

@@ -28,8 +28,7 @@ use distributions::{ziggurat, ziggurat_tables, Distribution, Open01};
 ///
 /// # Example
 /// ```rust
-/// use rand::{FromEntropy, Rng};
-/// use rand::rngs::SmallRng;
+/// use rand::prelude::*;
 /// use rand::distributions::StandardNormal;
 ///
 /// let val: f64 = SmallRng::from_entropy().sample(StandardNormal);

src/distributions/uniform.rs

@@ -53,10 +53,9 @@
 //! The example below merely wraps another back-end.
 //!
 //! ```
-//! use rand::{Rng, thread_rng};
-//! use rand::distributions::Distribution;
-//! use rand::distributions::uniform::{Uniform, SampleUniform};
-//! use rand::distributions::uniform::{UniformSampler, UniformFloat};
+//! use rand::prelude::*;
+//! use rand::distributions::uniform::{Uniform, SampleUniform,
+//!         UniformSampler, UniformFloat};
 //!
 //! #[derive(Clone, Copy, PartialEq, PartialOrd)]
 //! struct MyF32(f32);

src/lib.rs

@@ -214,6 +214,7 @@ pub mod distributions;
 pub mod entropy;
 pub mod mock;   // Public so we don't export `StepRng` directly, making it a bit
                 // more clear it is intended for testing.
+pub mod prelude;
 pub mod prng;
 #[cfg(feature="std")] pub mod read;
 pub mod reseeding;
@@ -809,10 +810,8 @@ pub trait FromEntropy: SeedableRng {
     /// errors, use the following code, equivalent aside from error handling:
     ///
     /// ```rust
-    /// # use rand::Error;
-    /// use rand::{Rng, SeedableRng};
-    /// use rand::entropy::EntropyRng;
-    /// use rand::rngs::StdRng;
+    /// use rand::{Error, prelude::*};
+    /// use rand::entropy::EntropyRng;;
     ///
     /// # fn try_inner() -> Result<(), Error> {
     /// // This uses StdRng, but is valid for any R: SeedableRng

src/prelude.rs

@@ -0,0 +1,28 @@
+// Copyright 2018 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// https://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// https://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or https://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+//! Convenience re-export of common members
+//!
+//! Like the standard library's prelude, this module simplifies importing of
+//! common items. Unlike the standard prelude, the contents of this module must
+//! be imported manually:
+//!
+//! ```
+//! use rand::prelude::*;
+//! # let _ = StdRng::from_entropy();
+//! # let mut r = SmallRng::from_rng(thread_rng()).unwrap();
+//! # let _: f32 = r.gen();
+//! ```
+
+#[doc(no_inline)] pub use distributions::Distribution;
+#[doc(no_inline)] pub use rngs::{SmallRng, StdRng};
+#[doc(no_inline)] #[cfg(feature="std")] pub use rngs::ThreadRng;
+#[doc(no_inline)] pub use {Rng, RngCore, CryptoRng, SeedableRng};
+#[doc(no_inline)] #[cfg(feature="std")] pub use {FromEntropy, random, thread_rng};