BlockRngCore: make item type an associated type

Author: dhardy

rand-core/src/impls.rs

@@ -19,6 +19,7 @@
 //! to/from byte sequences, and since its purpose is reproducibility,
 //! non-reproducible sources (e.g. `OsRng`) need not bother with it.
 
+use core::convert::AsRef;
 use core::intrinsics::transmute;
 use core::ptr::copy_nonoverlapping;
 use core::{fmt, slice};
@@ -183,14 +184,14 @@ pub fn next_u64_via_fill<R: RngCore + ?Sized>(rng: &mut R) -> u64 {
 /// [`RngCore`]: ../RngCore.t.html
 /// [`SeedableRng`]: ../SeedableRng.t.html
 #[derive(Clone)]
-pub struct BlockRng<T, R: BlockRngCore<T>> {
+pub struct BlockRng<R: BlockRngCore> {
     pub core: R,
     pub results: R::Results,
     pub index: usize,
 }
 
 // Custom Debug implementation that does not expose the contents of `results`.
-impl<T, R: BlockRngCore<T> + fmt::Debug> fmt::Debug for BlockRng<T, R> {
+impl<R: BlockRngCore + fmt::Debug> fmt::Debug for BlockRng<R> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("BlockRng")
            .field("core", &self.core)
@@ -200,7 +201,9 @@ impl<T, R: BlockRngCore<T> + fmt::Debug> fmt::Debug for BlockRng<T, R> {
     }
 }
 
-impl<R: BlockRngCore<u32>> RngCore for BlockRng<u32, R> {
+impl<R: BlockRngCore<Item=u32>> RngCore for BlockRng<R>
+where <R as BlockRngCore>::Results: AsRef<[u32]>
+{
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
         if self.index >= self.results.as_ref().len() {
@@ -308,7 +311,7 @@ impl<R: BlockRngCore<u32>> RngCore for BlockRng<u32, R> {
     }
 }
 
-impl<R: BlockRngCore<u32> + SeedableRng> SeedableRng for BlockRng<u32, R> {
+impl<R: BlockRngCore + SeedableRng> SeedableRng for BlockRng<R> {
     type Seed = R::Seed;
 
     fn from_seed(seed: Self::Seed) -> Self {
@@ -330,6 +333,6 @@ impl<R: BlockRngCore<u32> + SeedableRng> SeedableRng for BlockRng<u32, R> {
     }
 }
 
-impl<T, R: BlockRngCore<T> + CryptoRng> CryptoRng for BlockRng<T, R> {}
+impl<R: BlockRngCore + CryptoRng> CryptoRng for BlockRng<R> {}
 
 // TODO: implement tests for the above

rand-core/src/lib.rs

@@ -200,10 +200,13 @@ pub trait RngCore {
 /// // Final RNG.
 /// type MyRng = BlockRng<u32, MyRngCore>;
 /// ```
-pub trait BlockRngCore<T>: Sized {
+pub trait BlockRngCore: Sized {
+    /// 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<[T]> + Default;
+    type Results: AsRef<[Self::Item]> + Default;
 
     /// Generate a new block of results.
     fn generate(&mut self, results: &mut Self::Results);

src/prng/chacha.rs

@@ -63,7 +63,7 @@ const STATE_WORDS: usize = 16;
 ///
 /// [`set_rounds`]: #method.set_counter
 #[derive(Clone, Debug)]
-pub struct ChaChaRng(BlockRng<u32, ChaChaCore>);
+pub struct ChaChaRng(BlockRng<ChaChaCore>);
 
 impl RngCore for ChaChaRng {
     #[inline]
@@ -91,11 +91,11 @@ impl SeedableRng for ChaChaRng {
     type Seed = <ChaChaCore as SeedableRng>::Seed;
 
     fn from_seed(seed: Self::Seed) -> Self {
-        ChaChaRng(BlockRng::<u32, ChaChaCore>::from_seed(seed))
+        ChaChaRng(BlockRng::<ChaChaCore>::from_seed(seed))
     }
 
     fn from_rng<R: RngCore>(rng: &mut R) -> Result<Self, Error> {
-        BlockRng::<u32, ChaChaCore>::from_rng(rng).map(|rng| ChaChaRng(rng))
+        BlockRng::<ChaChaCore>::from_rng(rng).map(|rng| ChaChaRng(rng))
     }
 }
 
@@ -219,7 +219,8 @@ macro_rules! double_round{
     }}
 }
 
-impl BlockRngCore<u32> for ChaChaCore {
+impl BlockRngCore for ChaChaCore {
+    type Item = u32;
     type Results = [u32; STATE_WORDS];
 
     fn generate(&mut self, results: &mut Self::Results) {

src/prng/hc128.rs

@@ -62,7 +62,7 @@ const SEED_WORDS: usize = 8; // 128 bit key followed by 128 bit iv
 /// [5]: Internet Engineering Task Force (Februari 2015),
 ///      ["Prohibiting RC4 Cipher Suites"](https://tools.ietf.org/html/rfc7465).
 #[derive(Clone, Debug)]
-pub struct Hc128Rng(BlockRng<u32, Hc128Core>);
+pub struct Hc128Rng(BlockRng<Hc128Core>);
 
 impl RngCore for Hc128Rng {
     #[inline(always)]
@@ -88,11 +88,11 @@ impl SeedableRng for Hc128Rng {
     type Seed = <Hc128Core as SeedableRng>::Seed;
 
     fn from_seed(seed: Self::Seed) -> Self {
-        Hc128Rng(BlockRng::<u32, Hc128Core>::from_seed(seed))
+        Hc128Rng(BlockRng::<Hc128Core>::from_seed(seed))
     }
 
     fn from_rng<R: RngCore>(rng: &mut R) -> Result<Self, Error> {
-        BlockRng::<u32, Hc128Core>::from_rng(rng).map(|rng| Hc128Rng(rng))
+        BlockRng::<Hc128Core>::from_rng(rng).map(|rng| Hc128Rng(rng))
     }
 }
 
@@ -112,7 +112,8 @@ impl fmt::Debug for Hc128Core {
     }
 }
 
-impl BlockRngCore<u32> for Hc128Core {
+impl BlockRngCore for Hc128Core {
+    type Item = u32;
     type Results = [u32; 16];
 
     fn generate(&mut self, results: &mut Self::Results) {

src/reseeding.rs

@@ -11,7 +11,6 @@
 //! A wrapper around another PRNG that reseeds it after it
 //! generates a certain number of random bytes.
 
-use core::marker::PhantomData;
 use core::mem::size_of;
 
 use rand_core::{RngCore, BlockRngCore, CryptoRng, SeedableRng, Error, ErrorKind};
@@ -54,12 +53,12 @@ use rand_core::impls::BlockRng;
 /// If handling the source error fails `ReseedingRng` will continue generating
 /// data from the wrapped PRNG without reseeding.
 #[derive(Debug)]
-pub struct ReseedingRng<T, R, Rsdr>(BlockRng<T, ReseedingCore<T, R, Rsdr>>)
-where R: BlockRngCore<T> + SeedableRng,
+pub struct ReseedingRng<R, Rsdr>(BlockRng<ReseedingCore<R, Rsdr>>)
+where R: BlockRngCore + SeedableRng,
       Rsdr: RngCore;
 
-impl<T, R, Rsdr> ReseedingRng<T, R, Rsdr>
-where R: BlockRngCore<T> + SeedableRng,
+impl<R, Rsdr> ReseedingRng<R, Rsdr>
+where R: BlockRngCore + SeedableRng,
       Rsdr: RngCore
 {
     /// Create a new `ReseedingRng` with the given parameters.
@@ -70,14 +69,13 @@ where R: BlockRngCore<T> + SeedableRng,
     /// * `threshold`: the number of generated bytes after which to reseed the RNG.
     /// * `reseeder`: the RNG to use for reseeding.
     pub fn new(rng: R, threshold: u64, reseeder: Rsdr)
-        -> ReseedingRng<T, R, Rsdr>
+        -> ReseedingRng<R, Rsdr>
     {
         assert!(threshold <= ::core::i64::MAX as u64);
         let results_empty = R::Results::default();
         ReseedingRng(
             BlockRng {
                 core: ReseedingCore {
-                    phantom: PhantomData,
                     inner: rng,
                     reseeder: reseeder,
                     threshold: threshold as i64,
@@ -97,8 +95,9 @@ where R: BlockRngCore<T> + SeedableRng,
 
 // TODO: this should be implemented for any type where the inner type
 // implements RngCore, but we can't specify that because ReseedingCore is private
-impl<R, Rsdr: RngCore> RngCore for ReseedingRng<u32, R, Rsdr>
-where R: BlockRngCore<u32> + SeedableRng
+impl<R, Rsdr: RngCore> RngCore for ReseedingRng<R, Rsdr>
+where R: BlockRngCore<Item = u32> + SeedableRng,
+    <R as BlockRngCore>::Results: AsRef<[u32]>
 {
     #[inline(always)]
     fn next_u32(&mut self) -> u32 {
@@ -119,24 +118,24 @@ where R: BlockRngCore<u32> + SeedableRng
     }
 }
 
-impl<T, R, Rsdr> CryptoRng for ReseedingRng<T, R, Rsdr>
-where R: BlockRngCore<T> + SeedableRng + CryptoRng,
+impl<R, Rsdr> CryptoRng for ReseedingRng<R, Rsdr>
+where R: BlockRngCore + SeedableRng + CryptoRng,
       Rsdr: RngCore + CryptoRng {}
 
 #[derive(Debug)]
-struct ReseedingCore<T, R, Rsdr> {
-    phantom: PhantomData<T>, // associated with R, but not a parameter; used below
+struct ReseedingCore<R, Rsdr> {
     inner: R,
     reseeder: Rsdr,
     threshold: i64,
     bytes_until_reseed: i64,
 }
 
-impl<T, R, Rsdr> BlockRngCore<T> for ReseedingCore<T, R, Rsdr>
-where R: BlockRngCore<T> + SeedableRng,
+impl<R, Rsdr> BlockRngCore for ReseedingCore<R, Rsdr>
+where R: BlockRngCore + SeedableRng,
       Rsdr: RngCore
 {
-    type Results = <R as BlockRngCore<T>>::Results;
+    type Item = <R as BlockRngCore>::Item;
+    type Results = <R as BlockRngCore>::Results;
 
     fn generate(&mut self, results: &mut Self::Results) {
         if self.bytes_until_reseed <= 0 {
@@ -145,14 +144,14 @@ where R: BlockRngCore<T> + SeedableRng,
             // returning from a non-inlined function.
             return self.reseed_and_generate(results);
         }
-        let num_bytes = results.as_ref().len() * size_of::<T>();
+        let num_bytes = results.as_ref().len() * size_of::<Self::Item>();
         self.bytes_until_reseed -= num_bytes as i64;
         self.inner.generate(results);
     }
 }
 
-impl<T, R, Rsdr> ReseedingCore<T, R, Rsdr>
-where R: BlockRngCore<T> + SeedableRng,
+impl<R, Rsdr> ReseedingCore<R, Rsdr>
+where R: BlockRngCore + SeedableRng,
       Rsdr: RngCore
 {
     /// Reseed the internal PRNG.
@@ -165,7 +164,7 @@ where R: BlockRngCore<T> + SeedableRng,
 
     #[inline(never)]
     fn reseed_and_generate(&mut self,
-                           results: &mut <Self as BlockRngCore<T>>::Results)
+                           results: &mut <Self as BlockRngCore>::Results)
     {
         trace!("Reseeding RNG after {} generated bytes",
                self.threshold - self.bytes_until_reseed);
@@ -182,14 +181,14 @@ where R: BlockRngCore<T> + SeedableRng,
             self.threshold
         };
 
-        let num_bytes = results.as_ref().len() * size_of::<T>();
+        let num_bytes = results.as_ref().len() * size_of::<<R as BlockRngCore>::Item>();
         self.bytes_until_reseed = threshold - num_bytes as i64;
         self.inner.generate(results);
     }
 }
 
-impl<T, R, Rsdr> CryptoRng for ReseedingCore<T, R, Rsdr>
-where R: BlockRngCore<T> + SeedableRng + CryptoRng,
+impl<R, Rsdr> CryptoRng for ReseedingCore<R, Rsdr>
+where R: BlockRngCore + SeedableRng + CryptoRng,
       Rsdr: RngCore + CryptoRng {}
 
 #[cfg(test)]

src/thread_rng.rs

@@ -32,11 +32,11 @@ const THREAD_RNG_RESEED_THRESHOLD: u64 = 32*1024*1024; // 32 MiB
 /// [`thread_rng`]: fn.thread_rng.html
 #[derive(Clone, Debug)]
 pub struct ThreadRng {
-    rng: Rc<RefCell<ReseedingRng<u32, Hc128Core, EntropyRng>>>,
+    rng: Rc<RefCell<ReseedingRng<Hc128Core, EntropyRng>>>,
 }
 
 thread_local!(
-    static THREAD_RNG_KEY: Rc<RefCell<ReseedingRng<u32, Hc128Core, EntropyRng>>> = {
+    static THREAD_RNG_KEY: Rc<RefCell<ReseedingRng<Hc128Core, EntropyRng>>> = {
         let mut entropy_source = EntropyRng::new();
         let r = Hc128Core::from_rng(&mut entropy_source).unwrap_or_else(|err|
                 panic!("could not initialize thread_rng: {}", err));