Update rand

Author: dhardy

src/lib.rs

@@ -334,6 +334,7 @@ pub fn fill<T: Fill>(dest: &mut [T]) {
 #[cfg(test)]
 mod test {
     use super::*;
+    use core::convert::Infallible;
 
     /// Construct a deterministic RNG with the given seed
     pub fn rng(seed: u64) -> impl RngCore {
@@ -355,19 +356,21 @@ mod test {
 
     #[derive(Clone)]
     pub struct StepRng(u64, u64);
-    impl RngCore for StepRng {
-        fn next_u32(&mut self) -> u32 {
-            self.next_u64() as u32
+    impl TryRngCore for StepRng {
+        type Error = Infallible;
+
+        fn try_next_u32(&mut self) -> Result<u32, Infallible> {
+            self.try_next_u64().map(|x| x as u32)
         }
 
-        fn next_u64(&mut self) -> u64 {
+        fn try_next_u64(&mut self) -> Result<u64, Infallible> {
             let res = self.0;
             self.0 = self.0.wrapping_add(self.1);
-            res
+            Ok(res)
         }
 
-        fn fill_bytes(&mut self, dst: &mut [u8]) {
-            rand_core::utils::fill_bytes_via_next_word(dst, || self.next_u64());
+        fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Infallible> {
+            rand_core::utils::fill_bytes_via_next_word(dst, || self.try_next_u64())
         }
     }
 

src/rng.rs

@@ -309,7 +309,7 @@ pub trait Rng: RngCore {
     /// rand::rng().fill(&mut arr[..]);
     /// ```
     ///
-    /// [`fill_bytes`]: RngCore::fill_bytes
+    /// [`fill_bytes`]: Self::fill_bytes
     #[track_caller]
     fn fill<T: Fill>(&mut self, dest: &mut [T]) {
         Fill::fill_slice(dest, self)

src/rngs/mod.rs

@@ -68,7 +68,8 @@
 //!
 //! ## Traits and functionality
 //!
-//! All generators implement [`RngCore`] and thus also [`Rng`][crate::Rng].
+//! All generators implement [`TryRngCore`]. Most implement [`RngCore`] (i.e.
+//! `TryRngCore<Error = Infallible>`) and thus also implement [`Rng`][crate::Rng].
 //! See also the [Random Values] chapter in the book.
 //!
 //! Secure RNGs may additionally implement the [`CryptoRng`] trait.
@@ -82,6 +83,7 @@
 //! [Our RNGs]: https://rust-random.github.io/book/guide-rngs.html
 //! [Random Values]: https://rust-random.github.io/book/guide-values.html
 //! [`Rng`]: crate::Rng
+//! [`TryRngCore`]: crate::TryRngCore
 //! [`RngCore`]: crate::RngCore
 //! [`CryptoRng`]: crate::CryptoRng
 //! [`SeedableRng`]: crate::SeedableRng

src/rngs/reseeding.rs

@@ -10,10 +10,11 @@
 //! A wrapper around another PRNG that reseeds it after it
 //! generates a certain number of random bytes.
 
+use core::convert::Infallible;
 use core::mem::size_of_val;
 
 use rand_core::block::{BlockRng, CryptoGenerator, Generator};
-use rand_core::{CryptoRng, RngCore, SeedableRng, TryCryptoRng, TryRngCore};
+use rand_core::{SeedableRng, TryCryptoRng, TryRngCore};
 
 /// A wrapper around any PRNG that implements [`Generator`], that adds the
 /// ability to reseed it.
@@ -93,34 +94,36 @@ where
     ///
     /// This discards any remaining random data in the cache.
     pub fn reseed(&mut self) -> Result<(), Rsdr::Error> {
-        self.0.reset();
+        self.0.reset_and_skip(0);
         self.0.core.reseed()
     }
 }
 
 // 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<const N: usize, G, Rsdr> RngCore for ReseedingRng<G, Rsdr>
+// implements TryRngCore, but we can't specify that because ReseedingCore is private
+impl<const N: usize, G, Rsdr> TryRngCore for ReseedingRng<G, Rsdr>
 where
     G: Generator<Output = [u32; N]> + SeedableRng,
     Rsdr: TryRngCore,
 {
+    type Error = Infallible;
+
     #[inline(always)]
-    fn next_u32(&mut self) -> u32 {
-        self.0.next_word()
+    fn try_next_u32(&mut self) -> Result<u32, Infallible> {
+        Ok(self.0.next_word())
     }
 
     #[inline(always)]
-    fn next_u64(&mut self) -> u64 {
-        self.0.next_u64_from_u32()
+    fn try_next_u64(&mut self) -> Result<u64, Infallible> {
+        Ok(self.0.next_u64_from_u32())
     }
 
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
-        self.0.fill_bytes(dest)
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Infallible> {
+        Ok(self.0.fill_bytes(dest))
     }
 }
 
-impl<const N: usize, G, Rsdr> CryptoRng for ReseedingRng<G, Rsdr>
+impl<const N: usize, G, Rsdr> TryCryptoRng for ReseedingRng<G, Rsdr>
 where
     G: Generator<Output = [u32; N]> + SeedableRng + CryptoGenerator,
     Rsdr: TryCryptoRng,

src/rngs/small.rs

@@ -8,7 +8,8 @@
 
 //! A small fast RNG
 
-use rand_core::{RngCore, SeedableRng};
+use core::convert::Infallible;
+use rand_core::{SeedableRng, TryRngCore};
 
 #[cfg(any(target_pointer_width = "32", target_pointer_width = "16"))]
 type Rng = super::xoshiro128plusplus::Xoshiro128PlusPlus;
@@ -95,19 +96,21 @@ impl SeedableRng for SmallRng {
     }
 }
 
-impl RngCore for SmallRng {
+impl TryRngCore for SmallRng {
+    type Error = Infallible;
+
     #[inline(always)]
-    fn next_u32(&mut self) -> u32 {
-        self.0.next_u32()
+    fn try_next_u32(&mut self) -> Result<u32, Infallible> {
+        self.0.try_next_u32()
     }
 
     #[inline(always)]
-    fn next_u64(&mut self) -> u64 {
-        self.0.next_u64()
+    fn try_next_u64(&mut self) -> Result<u64, Infallible> {
+        self.0.try_next_u64()
     }
 
     #[inline(always)]
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
-        self.0.fill_bytes(dest)
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Infallible> {
+        self.0.try_fill_bytes(dest)
     }
 }

src/rngs/std.rs

@@ -8,7 +8,8 @@
 
 //! The standard RNG
 
-use rand_core::{CryptoRng, RngCore, SeedableRng};
+use core::convert::Infallible;
+use rand_core::{SeedableRng, TryCryptoRng, TryRngCore};
 
 #[cfg(any(test, feature = "sys_rng"))]
 pub(crate) use chacha20::ChaCha12Core as Core;
@@ -69,20 +70,22 @@ use chacha20::ChaCha12Rng as Rng;
 #[derive(Debug, PartialEq, Eq)]
 pub struct StdRng(Rng);
 
-impl RngCore for StdRng {
+impl TryRngCore for StdRng {
+    type Error = Infallible;
+
     #[inline(always)]
-    fn next_u32(&mut self) -> u32 {
-        self.0.next_u32()
+    fn try_next_u32(&mut self) -> Result<u32, Infallible> {
+        self.0.try_next_u32()
     }
 
     #[inline(always)]
-    fn next_u64(&mut self) -> u64 {
-        self.0.next_u64()
+    fn try_next_u64(&mut self) -> Result<u64, Infallible> {
+        self.0.try_next_u64()
     }
 
     #[inline(always)]
-    fn fill_bytes(&mut self, dst: &mut [u8]) {
-        self.0.fill_bytes(dst)
+    fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Infallible> {
+        self.0.try_fill_bytes(dst)
     }
 }
 
@@ -96,7 +99,7 @@ impl SeedableRng for StdRng {
     }
 }
 
-impl CryptoRng for StdRng {}
+impl TryCryptoRng for StdRng {}
 
 #[cfg(test)]
 mod test {

src/rngs/thread.rs

@@ -8,13 +8,13 @@
 
 //! Thread-local random number generator
 
-use core::cell::UnsafeCell;
+use core::{cell::UnsafeCell, convert::Infallible};
 use std::fmt;
 use std::rc::Rc;
 use std::thread_local;
 
 use super::{ReseedingRng, SysError, SysRng, std::Core};
-use rand_core::{CryptoRng, RngCore};
+use rand_core::{TryCryptoRng, TryRngCore};
 
 // Rationale for using `UnsafeCell` in `ThreadRng`:
 //
@@ -162,33 +162,35 @@ impl Default for ThreadRng {
     }
 }
 
-impl RngCore for ThreadRng {
+impl TryRngCore for ThreadRng {
+    type Error = Infallible;
+
     #[inline(always)]
-    fn next_u32(&mut self) -> u32 {
+    fn try_next_u32(&mut self) -> Result<u32, Infallible> {
         // SAFETY: We must make sure to stop using `rng` before anyone else
         // creates another mutable reference
         let rng = unsafe { &mut *self.rng.get() };
-        rng.next_u32()
+        rng.try_next_u32()
     }
 
     #[inline(always)]
-    fn next_u64(&mut self) -> u64 {
+    fn try_next_u64(&mut self) -> Result<u64, Infallible> {
         // SAFETY: We must make sure to stop using `rng` before anyone else
         // creates another mutable reference
         let rng = unsafe { &mut *self.rng.get() };
-        rng.next_u64()
+        rng.try_next_u64()
     }
 
     #[inline(always)]
-    fn fill_bytes(&mut self, dest: &mut [u8]) {
+    fn try_fill_bytes(&mut self, dest: &mut [u8]) -> Result<(), Infallible> {
         // SAFETY: We must make sure to stop using `rng` before anyone else
         // creates another mutable reference
         let rng = unsafe { &mut *self.rng.get() };
-        rng.fill_bytes(dest)
+        rng.try_fill_bytes(dest)
     }
 }
 
-impl CryptoRng for ThreadRng {}
+impl TryCryptoRng for ThreadRng {}
 
 #[cfg(test)]
 mod test {

src/rngs/xoshiro128plusplus.rs

@@ -6,7 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use rand_core::{RngCore, SeedableRng, utils};
+use core::convert::Infallible;
+use rand_core::{SeedableRng, TryRngCore, utils};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -63,9 +64,11 @@ impl SeedableRng for Xoshiro128PlusPlus {
     }
 }
 
-impl RngCore for Xoshiro128PlusPlus {
+impl TryRngCore for Xoshiro128PlusPlus {
+    type Error = Infallible;
+
     #[inline]
-    fn next_u32(&mut self) -> u32 {
+    fn try_next_u32(&mut self) -> Result<u32, Infallible> {
         let res = self.s[0]
             .wrapping_add(self.s[3])
             .rotate_left(7)
@@ -82,17 +85,17 @@ impl RngCore for Xoshiro128PlusPlus {
 
         self.s[3] = self.s[3].rotate_left(11);
 
-        res
+        Ok(res)
     }
 
     #[inline]
-    fn next_u64(&mut self) -> u64 {
+    fn try_next_u64(&mut self) -> Result<u64, Infallible> {
         utils::next_u64_via_u32(self)
     }
 
     #[inline]
-    fn fill_bytes(&mut self, dst: &mut [u8]) {
-        utils::fill_bytes_via_next_word(dst, || self.next_u32());
+    fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Infallible> {
+        utils::fill_bytes_via_next_word(dst, || self.try_next_u32())
     }
 }
 

src/rngs/xoshiro256plusplus.rs

@@ -6,7 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use rand_core::{RngCore, SeedableRng, utils};
+use core::convert::Infallible;
+use rand_core::{SeedableRng, TryRngCore, utils};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 
@@ -62,17 +63,18 @@ impl SeedableRng for Xoshiro256PlusPlus {
     }
 }
 
-impl RngCore for Xoshiro256PlusPlus {
+impl TryRngCore for Xoshiro256PlusPlus {
+    type Error = Infallible;
+
     #[inline]
-    fn next_u32(&mut self) -> u32 {
+    fn try_next_u32(&mut self) -> Result<u32, Infallible> {
         // The lowest bits have some linear dependencies, so we use the
         // upper bits instead.
-        let val = self.next_u64();
-        (val >> 32) as u32
+        self.try_next_u64().map(|val| (val >> 32) as u32)
     }
 
     #[inline]
-    fn next_u64(&mut self) -> u64 {
+    fn try_next_u64(&mut self) -> Result<u64, Infallible> {
         let res = self.s[0]
             .wrapping_add(self.s[3])
             .rotate_left(23)
@@ -89,12 +91,12 @@ impl RngCore for Xoshiro256PlusPlus {
 
         self.s[3] = self.s[3].rotate_left(45);
 
-        res
+        Ok(res)
     }
 
     #[inline]
-    fn fill_bytes(&mut self, dst: &mut [u8]) {
-        utils::fill_bytes_via_next_word(dst, || self.next_u64());
+    fn try_fill_bytes(&mut self, dst: &mut [u8]) -> Result<(), Infallible> {
+        utils::fill_bytes_via_next_word(dst, || self.try_next_u64())
     }
 }