Move BlockRng* to new rand_core::block module; don't export from rand

These are almost exclusively for implementation of certain types of RNG,
therefore exposing BlockRngCore in rand is not useful.

Author: dhardy

rand_core/src/block.rs

@@ -59,6 +59,7 @@ pub use error::{ErrorKind, Error};
 
 
 mod error;
+pub mod block;
 pub mod impls;
 pub mod le;
 
@@ -191,59 +192,6 @@ pub trait RngCore {
     fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Error>;
 }
 
-/// A trait for RNGs which do not generate random numbers individually, but in
-/// blocks (typically `[u32; N]`). This technique is commonly used by
-/// cryptographic RNGs to improve performance.
-/// 
-/// Usage of this trait is optional, but provides two advantages:
-/// implementations only need to concern themselves with generation of the
-/// block, not the various [`RngCore`] methods (especially [`fill_bytes`], where the
-/// optimal implementations are not trivial), and this allows `ReseedingRng` to
-/// perform periodic reseeding with very low overhead.
-/// 
-/// # Example
-/// 
-/// ```norun
-/// use rand_core::BlockRngCore;
-/// use rand_core::impls::BlockRng;
-/// 
-/// struct MyRngCore;
-/// 
-/// impl BlockRngCore for MyRngCore {
-///     type Results = [u32; 16];
-///     
-///     fn generate(&mut self, results: &mut Self::Results) {
-///         unimplemented!()
-///     }
-/// }
-/// 
-/// impl SeedableRng for MyRngCore {
-///     type Seed = unimplemented!();
-///     fn from_seed(seed: Self::Seed) -> Self {
-///         unimplemented!()
-///     }
-/// }
-/// 
-/// // optionally, also implement CryptoRng for MyRngCore
-/// 
-/// // Final RNG.
-/// type MyRng = BlockRng<u32, MyRngCore>;
-/// ```
-/// 
-/// [`RngCore`]: trait.RngCore.html
-/// [`fill_bytes`]: trait.RngCore.html#tymethod.fill_bytes
-pub trait BlockRngCore {
-    /// Results element type, e.g. `u32`.
-    type Item;
-    
-    /// Results type. This is the 'block' an RNG implementing `BlockRngCore`
-    /// generates, which will usually be an array like `[u32; 16]`.
-    type Results: AsRef<[Self::Item]> + AsMut<[Self::Item]> + Default;
-
-    /// Generate a new block of results.
-    fn generate(&mut self, results: &mut Self::Results);
-}
-
 /// A marker trait used to indicate that an [`RngCore`] or [`BlockRngCore`]
 /// implementation is supposed to be cryptographically secure.
 /// 
@@ -266,7 +214,7 @@ pub trait BlockRngCore {
 /// weaknesses such as seeding from a weak entropy source or leaking state.
 /// 
 /// [`RngCore`]: trait.RngCore.html
-/// [`BlockRngCore`]: trait.BlockRngCore.html
+/// [`BlockRngCore`]: ../rand_core/block/trait.BlockRngCore.html
 pub trait CryptoRng {}
 
 /// A random number generator that can be explicitly seeded.

rand_core/src/impls.rs

@@ -203,7 +203,7 @@ extern crate rand_core;
 
 
 // Re-exports from rand_core
-pub use rand_core::{RngCore, BlockRngCore, CryptoRng, SeedableRng};
+pub use rand_core::{RngCore, CryptoRng, SeedableRng};
 pub use rand_core::{ErrorKind, Error};
 
 // Public exports

rand_core/src/lib.rs

@@ -11,8 +11,8 @@
 //! The ChaCha random number generator.
 
 use core::fmt;
-use rand_core::{BlockRngCore, CryptoRng, RngCore, SeedableRng, Error, le};
-use rand_core::impls::BlockRng;
+use rand_core::{CryptoRng, RngCore, SeedableRng, Error, le};
+use rand_core::block::{BlockRngCore, BlockRng};
 
 const SEED_WORDS: usize = 8; // 8 words for the 256-bit key
 const STATE_WORDS: usize = 16;

src/lib.rs

@@ -11,8 +11,8 @@
 //! The HC-128 random number generator.
 
 use core::fmt;
-use rand_core::{BlockRngCore, CryptoRng, RngCore, SeedableRng, Error, le};
-use rand_core::impls::BlockRng;
+use rand_core::{CryptoRng, RngCore, SeedableRng, Error, le};
+use rand_core::block::{BlockRngCore, BlockRng};
 
 const SEED_WORDS: usize = 8; // 128 bit key followed by 128 bit iv
 

src/prng/chacha.rs

@@ -12,8 +12,8 @@
 
 use core::{fmt, slice};
 use core::num::Wrapping as w;
-use rand_core::{BlockRngCore, RngCore, SeedableRng, Error, le};
-use rand_core::impls::BlockRng;
+use rand_core::{RngCore, SeedableRng, Error, le};
+use rand_core::block::{BlockRngCore, BlockRng};
 use prng::isaac_array::IsaacArray;
 
 #[allow(non_camel_case_types)]

src/prng/hc128.rs

@@ -12,8 +12,8 @@
 
 use core::{fmt, slice};
 use core::num::Wrapping as w;
-use rand_core::{BlockRngCore, RngCore, SeedableRng, Error, le};
-use rand_core::impls::BlockRng64;
+use rand_core::{RngCore, SeedableRng, Error, le};
+use rand_core::block::{BlockRngCore, BlockRng64};
 use prng::isaac_array::IsaacArray;
 
 #[allow(non_camel_case_types)]

src/prng/isaac.rs

@@ -13,8 +13,8 @@
 
 use core::mem::size_of;
 
-use rand_core::{RngCore, BlockRngCore, CryptoRng, SeedableRng, Error, ErrorKind};
-use rand_core::impls::BlockRng;
+use rand_core::{RngCore, CryptoRng, SeedableRng, Error, ErrorKind};
+use rand_core::block::{BlockRngCore, BlockRng};
 
 /// A wrapper around any PRNG which reseeds the underlying PRNG after it has
 /// generated a certain number of random bytes.