Rename Generator::Results -> Output

Author: dhardy

src/block.rs

@@ -20,9 +20,9 @@
 //! struct MyRngCore;
 //!
 //! impl Generator for MyRngCore {
-//!     type Results = [u32; 16];
+//!     type Output = [u32; 16];
 //!
-//!     fn generate(&mut self, results: &mut Self::Results) {
+//!     fn generate(&mut self, output: &mut Self::Output) {
 //!         unimplemented!()
 //!     }
 //! }
@@ -52,12 +52,15 @@ use serde::{Deserialize, Serialize};
 
 /// A random (block) generator
 pub trait Generator {
-    /// Results type. This is the 'block' an RNG implementing `BlockRngCore`
-    /// generates, which will usually be an array like `[u32; 16]`.
-    type Results;
+    /// The output type.
+    ///
+    /// For use with [`rand_core::block`](crate::block) code this must be `[u32; _]` or `[u64; _]`.
+    type Output;
 
-    /// Generate a new block of results.
-    fn generate(&mut self, results: &mut Self::Results);
+    /// Generate a new block of `output`.
+    ///
+    /// This must fill `output` with random data.
+    fn generate(&mut self, output: &mut Self::Output);
 }
 
 /// A cryptographically secure generator
@@ -110,18 +113,18 @@ pub trait CryptoGenerator: Generator {}
 #[cfg_attr(
     feature = "serde",
     serde(
-        bound = "for<'x> R: Serialize + Deserialize<'x>, for<'x> R::Results: Serialize + Deserialize<'x>"
+        bound = "for<'x> R: Serialize + Deserialize<'x>, for<'x> R::Output: Serialize + Deserialize<'x>"
     )
 )]
 pub struct BlockRng<R: Generator> {
-    results: R::Results,
+    results: R::Output,
     index: usize,
     /// The *core* part of the RNG, implementing the `generate` function.
     pub core: R,
 }
 
 // Custom Debug implementation that does not expose the contents of `results`.
-impl<const N: usize, R: Generator<Results = [u32; N]> + fmt::Debug> fmt::Debug for BlockRng<R> {
+impl<const N: usize, R: Generator<Output = [u32; N]> + fmt::Debug> fmt::Debug for BlockRng<R> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("BlockRng")
             .field("core", &self.core)
@@ -131,7 +134,7 @@ impl<const N: usize, R: Generator<Results = [u32; N]> + fmt::Debug> fmt::Debug f
     }
 }
 
-impl<const N: usize, R: Generator<Results = [u32; N]>> BlockRng<R> {
+impl<const N: usize, R: Generator<Output = [u32; N]>> BlockRng<R> {
     /// Create a new `BlockRng` from an existing RNG implementing
     /// `Generator`. Results will be generated on first use.
     #[inline]
@@ -170,7 +173,7 @@ impl<const N: usize, R: Generator<Results = [u32; N]>> BlockRng<R> {
     }
 }
 
-impl<const N: usize, R: Generator<Results = [u32; N]>> RngCore for BlockRng<R> {
+impl<const N: usize, R: Generator<Output = [u32; N]>> RngCore for BlockRng<R> {
     #[inline]
     fn next_u32(&mut self) -> u32 {
         if self.index >= self.results.as_ref().len() {
@@ -223,7 +226,7 @@ impl<const N: usize, R: Generator<Results = [u32; N]>> RngCore for BlockRng<R> {
     }
 }
 
-impl<const N: usize, R: Generator<Results = [u32; N]> + SeedableRng> SeedableRng for BlockRng<R> {
+impl<const N: usize, R: Generator<Output = [u32; N]> + SeedableRng> SeedableRng for BlockRng<R> {
     type Seed = R::Seed;
 
     #[inline(always)]
@@ -247,7 +250,7 @@ impl<const N: usize, R: Generator<Results = [u32; N]> + SeedableRng> SeedableRng
     }
 }
 
-impl<const N: usize, R: CryptoGenerator<Results = [u32; N]>> CryptoRng for BlockRng<R> {}
+impl<const N: usize, R: CryptoGenerator<Output = [u32; N]>> CryptoRng for BlockRng<R> {}
 
 /// A wrapper type implementing [`RngCore`] for some type implementing
 /// [`Generator`] with `u64` array buffer; i.e. this can be used to implement
@@ -272,15 +275,15 @@ impl<const N: usize, R: CryptoGenerator<Results = [u32; N]>> CryptoRng for Block
 #[derive(Clone)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 pub struct BlockRng64<R: Generator + ?Sized> {
-    results: R::Results,
+    results: R::Output,
     index: usize,
     half_used: bool, // true if only half of the previous result is used
     /// The *core* part of the RNG, implementing the `generate` function.
     pub core: R,
 }
 
 // Custom Debug implementation that does not expose the contents of `results`.
-impl<const N: usize, R: Generator<Results = [u64; N]> + fmt::Debug> fmt::Debug for BlockRng64<R> {
+impl<const N: usize, R: Generator<Output = [u64; N]> + fmt::Debug> fmt::Debug for BlockRng64<R> {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         fmt.debug_struct("BlockRng64")
             .field("core", &self.core)
@@ -291,7 +294,7 @@ impl<const N: usize, R: Generator<Results = [u64; N]> + fmt::Debug> fmt::Debug f
     }
 }
 
-impl<const N: usize, R: Generator<Results = [u64; N]>> BlockRng64<R> {
+impl<const N: usize, R: Generator<Output = [u64; N]>> BlockRng64<R> {
     /// Create a new `BlockRng` from an existing RNG implementing
     /// `Generator`. Results will be generated on first use.
     #[inline]
@@ -334,7 +337,7 @@ impl<const N: usize, R: Generator<Results = [u64; N]>> BlockRng64<R> {
     }
 }
 
-impl<const N: usize, R: Generator<Results = [u64; N]>> RngCore for BlockRng64<R> {
+impl<const N: usize, R: Generator<Output = [u64; N]>> RngCore for BlockRng64<R> {
     #[inline]
     fn next_u32(&mut self) -> u32 {
         let mut index = self.index - self.half_used as usize;
@@ -386,7 +389,7 @@ impl<const N: usize, R: Generator<Results = [u64; N]>> RngCore for BlockRng64<R>
     }
 }
 
-impl<const N: usize, R: Generator<Results = [u64; N]> + SeedableRng> SeedableRng for BlockRng64<R> {
+impl<const N: usize, R: Generator<Output = [u64; N]> + SeedableRng> SeedableRng for BlockRng64<R> {
     type Seed = R::Seed;
 
     #[inline(always)]
@@ -410,7 +413,7 @@ impl<const N: usize, R: Generator<Results = [u64; N]> + SeedableRng> SeedableRng
     }
 }
 
-impl<const N: usize, R: CryptoGenerator<Results = [u64; N]>> CryptoRng for BlockRng64<R> {}
+impl<const N: usize, R: CryptoGenerator<Output = [u64; N]>> CryptoRng for BlockRng64<R> {}
 
 #[cfg(test)]
 mod test {
@@ -423,11 +426,11 @@ mod test {
     }
 
     impl Generator for DummyRng {
-        type Results = [u32; 16];
+        type Output = [u32; 16];
 
-        fn generate(&mut self, results: &mut Self::Results) {
-            for r in results {
-                *r = self.counter;
+        fn generate(&mut self, output: &mut Self::Output) {
+            for item in output {
+                *item = self.counter;
                 self.counter = self.counter.wrapping_add(3511615421);
             }
         }
@@ -473,11 +476,11 @@ mod test {
     }
 
     impl Generator for DummyRng64 {
-        type Results = [u64; 8];
+        type Output = [u64; 8];
 
-        fn generate(&mut self, results: &mut Self::Results) {
-            for r in results {
-                *r = self.counter;
+        fn generate(&mut self, output: &mut Self::Output) {
+            for item in output {
+                *item = self.counter;
                 self.counter = self.counter.wrapping_add(2781463553396133981);
             }
         }