Add TryRngCore and TryCryptoRng traits (#1424)

This reworks fallibility, replacing the fixed `Error` type.
rust-random · May 8, 2024 · fba5521 · fba5521
1 parent 1f81878
commit fba5521
Show file tree

Hide file tree

Showing 38 changed files with 641 additions and 759 deletions.
diff --git a/README.md b/README.md
@@ -92,7 +92,7 @@ compiler versions will be compatible. This is especially true of Rand's
 experimental `simd_support` feature.
 
 Rand supports limited functionality in `no_std` mode (enabled via
-`default-features = false`). In this case, `OsRng` and `from_entropy` are
+`default-features = false`). In this case, `OsRng` and `from_os_rng` are
 unavailable (unless `getrandom` is enabled), large parts of `seq` are
 unavailable (unless `alloc` is enabled), and `thread_rng` and `random` are
 unavailable.

diff --git a/benches/benches/base_distributions.rs b/benches/benches/base_distributions.rs
@@ -32,7 +32,7 @@ macro_rules! distr_int {
     ($fnn:ident, $ty:ty, $distr:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
             let distr = $distr;
 
             b.iter(|| {
@@ -52,7 +52,7 @@ macro_rules! distr_nz_int {
     ($fnn:ident, $tynz:ty, $ty:ty, $distr:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
             let distr = $distr;
 
             b.iter(|| {
@@ -72,7 +72,7 @@ macro_rules! distr_float {
     ($fnn:ident, $ty:ty, $distr:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
             let distr = $distr;
 
             b.iter(|| {
@@ -92,7 +92,7 @@ macro_rules! distr_duration {
     ($fnn:ident, $distr:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
             let distr = $distr;
 
             b.iter(|| {
@@ -114,7 +114,7 @@ macro_rules! distr {
     ($fnn:ident, $ty:ty, $distr:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
             let distr = $distr;
 
             b.iter(|| {
@@ -191,15 +191,15 @@ macro_rules! gen_range_int {
     ($fnn:ident, $ty:ident, $low:expr, $high:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
 
             b.iter(|| {
                 let mut high = $high;
                 let mut accum: $ty = 0;
                 for _ in 0..RAND_BENCH_N {
                     accum = accum.wrapping_add(rng.gen_range($low..high));
                     // force recalculation of range each time
-                    high = high.wrapping_add(1) & core::$ty::MAX;
+                    high = high.wrapping_add(1) & $ty::MAX;
                 }
                 accum
             });
@@ -230,7 +230,7 @@ macro_rules! gen_range_float {
     ($fnn:ident, $ty:ident, $low:expr, $high:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
 
             b.iter(|| {
                 let mut high = $high;
@@ -267,7 +267,7 @@ macro_rules! uniform_sample {
     ($fnn:ident, $type:ident, $low:expr, $high:expr, $count:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
             let low = black_box($low);
             let high = black_box($high);
             b.iter(|| {
@@ -286,7 +286,7 @@ macro_rules! uniform_inclusive {
     ($fnn:ident, $type:ident, $low:expr, $high:expr, $count:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
             let low = black_box($low);
             let high = black_box($high);
             b.iter(|| {
@@ -306,7 +306,7 @@ macro_rules! uniform_single {
     ($fnn:ident, $type:ident, $low:expr, $high:expr, $count:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg64Mcg::from_entropy();
+            let mut rng = Pcg64Mcg::from_os_rng();
             let low = black_box($low);
             let high = black_box($high);
             b.iter(|| {

diff --git a/benches/benches/generators.rs b/benches/benches/generators.rs
@@ -15,13 +15,14 @@ const RAND_BENCH_N: u64 = 1000;
 const BYTES_LEN: usize = 1024;
 
 use core::mem::size_of;
+use rand_chacha::rand_core::UnwrapErr;
 use test::{black_box, Bencher};
 
 use rand::prelude::*;
 use rand::rngs::ReseedingRng;
 use rand::rngs::{mock::StepRng, OsRng};
 use rand_chacha::{ChaCha12Rng, ChaCha20Core, ChaCha20Rng, ChaCha8Rng};
-use rand_pcg::{Pcg32, Pcg64, Pcg64Mcg, Pcg64Dxsm};
+use rand_pcg::{Pcg32, Pcg64, Pcg64Dxsm, Pcg64Mcg};
 
 macro_rules! gen_bytes {
     ($fnn:ident, $gen:expr) => {
@@ -41,17 +42,17 @@ macro_rules! gen_bytes {
 }
 
 gen_bytes!(gen_bytes_step, StepRng::new(0, 1));
-gen_bytes!(gen_bytes_pcg32, Pcg32::from_entropy());
-gen_bytes!(gen_bytes_pcg64, Pcg64::from_entropy());
-gen_bytes!(gen_bytes_pcg64mcg, Pcg64Mcg::from_entropy());
-gen_bytes!(gen_bytes_pcg64dxsm, Pcg64Dxsm::from_entropy());
-gen_bytes!(gen_bytes_chacha8, ChaCha8Rng::from_entropy());
-gen_bytes!(gen_bytes_chacha12, ChaCha12Rng::from_entropy());
-gen_bytes!(gen_bytes_chacha20, ChaCha20Rng::from_entropy());
-gen_bytes!(gen_bytes_std, StdRng::from_entropy());
+gen_bytes!(gen_bytes_pcg32, Pcg32::from_os_rng());
+gen_bytes!(gen_bytes_pcg64, Pcg64::from_os_rng());
+gen_bytes!(gen_bytes_pcg64mcg, Pcg64Mcg::from_os_rng());
+gen_bytes!(gen_bytes_pcg64dxsm, Pcg64Dxsm::from_os_rng());
+gen_bytes!(gen_bytes_chacha8, ChaCha8Rng::from_os_rng());
+gen_bytes!(gen_bytes_chacha12, ChaCha12Rng::from_os_rng());
+gen_bytes!(gen_bytes_chacha20, ChaCha20Rng::from_os_rng());
+gen_bytes!(gen_bytes_std, StdRng::from_os_rng());
 #[cfg(feature = "small_rng")]
 gen_bytes!(gen_bytes_small, SmallRng::from_thread_rng());
-gen_bytes!(gen_bytes_os, OsRng);
+gen_bytes!(gen_bytes_os, UnwrapErr(OsRng));
 gen_bytes!(gen_bytes_thread, thread_rng());
 
 macro_rules! gen_uint {
@@ -62,7 +63,7 @@ macro_rules! gen_uint {
             b.iter(|| {
                 let mut accum: $ty = 0;
                 for _ in 0..RAND_BENCH_N {
-                    accum = accum.wrapping_add(rng.gen::<$ty>());
+                    accum = accum.wrapping_add(rng.random::<$ty>());
                 }
                 accum
             });
@@ -72,40 +73,40 @@ macro_rules! gen_uint {
 }
 
 gen_uint!(gen_u32_step, u32, StepRng::new(0, 1));
-gen_uint!(gen_u32_pcg32, u32, Pcg32::from_entropy());
-gen_uint!(gen_u32_pcg64, u32, Pcg64::from_entropy());
-gen_uint!(gen_u32_pcg64mcg, u32, Pcg64Mcg::from_entropy());
-gen_uint!(gen_u32_pcg64dxsm, u32, Pcg64Dxsm::from_entropy());
-gen_uint!(gen_u32_chacha8, u32, ChaCha8Rng::from_entropy());
-gen_uint!(gen_u32_chacha12, u32, ChaCha12Rng::from_entropy());
-gen_uint!(gen_u32_chacha20, u32, ChaCha20Rng::from_entropy());
-gen_uint!(gen_u32_std, u32, StdRng::from_entropy());
+gen_uint!(gen_u32_pcg32, u32, Pcg32::from_os_rng());
+gen_uint!(gen_u32_pcg64, u32, Pcg64::from_os_rng());
+gen_uint!(gen_u32_pcg64mcg, u32, Pcg64Mcg::from_os_rng());
+gen_uint!(gen_u32_pcg64dxsm, u32, Pcg64Dxsm::from_os_rng());
+gen_uint!(gen_u32_chacha8, u32, ChaCha8Rng::from_os_rng());
+gen_uint!(gen_u32_chacha12, u32, ChaCha12Rng::from_os_rng());
+gen_uint!(gen_u32_chacha20, u32, ChaCha20Rng::from_os_rng());
+gen_uint!(gen_u32_std, u32, StdRng::from_os_rng());
 #[cfg(feature = "small_rng")]
 gen_uint!(gen_u32_small, u32, SmallRng::from_thread_rng());
-gen_uint!(gen_u32_os, u32, OsRng);
+gen_uint!(gen_u32_os, u32, UnwrapErr(OsRng));
 gen_uint!(gen_u32_thread, u32, thread_rng());
 
 gen_uint!(gen_u64_step, u64, StepRng::new(0, 1));
-gen_uint!(gen_u64_pcg32, u64, Pcg32::from_entropy());
-gen_uint!(gen_u64_pcg64, u64, Pcg64::from_entropy());
-gen_uint!(gen_u64_pcg64mcg, u64, Pcg64Mcg::from_entropy());
-gen_uint!(gen_u64_pcg64dxsm, u64, Pcg64Dxsm::from_entropy());
-gen_uint!(gen_u64_chacha8, u64, ChaCha8Rng::from_entropy());
-gen_uint!(gen_u64_chacha12, u64, ChaCha12Rng::from_entropy());
-gen_uint!(gen_u64_chacha20, u64, ChaCha20Rng::from_entropy());
-gen_uint!(gen_u64_std, u64, StdRng::from_entropy());
+gen_uint!(gen_u64_pcg32, u64, Pcg32::from_os_rng());
+gen_uint!(gen_u64_pcg64, u64, Pcg64::from_os_rng());
+gen_uint!(gen_u64_pcg64mcg, u64, Pcg64Mcg::from_os_rng());
+gen_uint!(gen_u64_pcg64dxsm, u64, Pcg64Dxsm::from_os_rng());
+gen_uint!(gen_u64_chacha8, u64, ChaCha8Rng::from_os_rng());
+gen_uint!(gen_u64_chacha12, u64, ChaCha12Rng::from_os_rng());
+gen_uint!(gen_u64_chacha20, u64, ChaCha20Rng::from_os_rng());
+gen_uint!(gen_u64_std, u64, StdRng::from_os_rng());
 #[cfg(feature = "small_rng")]
 gen_uint!(gen_u64_small, u64, SmallRng::from_thread_rng());
-gen_uint!(gen_u64_os, u64, OsRng);
+gen_uint!(gen_u64_os, u64, UnwrapErr(OsRng));
 gen_uint!(gen_u64_thread, u64, thread_rng());
 
 macro_rules! init_gen {
     ($fnn:ident, $gen:ident) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = Pcg32::from_entropy();
+            let mut rng = Pcg32::from_os_rng();
             b.iter(|| {
-                let r2 = $gen::from_rng(&mut rng).unwrap();
+                let r2 = $gen::from_rng(&mut rng);
                 r2
             });
         }
@@ -125,7 +126,7 @@ macro_rules! reseeding_bytes {
     ($fnn:ident, $thresh:expr) => {
         #[bench]
         fn $fnn(b: &mut Bencher) {
-            let mut rng = ReseedingRng::new(ChaCha20Core::from_entropy(), $thresh * 1024, OsRng);
+            let mut rng = ReseedingRng::new(ChaCha20Core::from_os_rng(), $thresh * 1024, OsRng);
             let mut buf = [0u8; RESEEDING_BYTES_LEN];
             b.iter(|| {
                 for _ in 0..RESEEDING_BENCH_N {

diff --git a/benches/benches/misc.rs b/benches/benches/misc.rs
@@ -20,7 +20,7 @@ use rand_pcg::{Pcg32, Pcg64Mcg};
 
 #[bench]
 fn misc_gen_bool_const(b: &mut Bencher) {
-    let mut rng = Pcg32::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg32::from_rng(&mut thread_rng());
     b.iter(|| {
         let mut accum = true;
         for _ in 0..RAND_BENCH_N {
@@ -32,7 +32,7 @@ fn misc_gen_bool_const(b: &mut Bencher) {
 
 #[bench]
 fn misc_gen_bool_var(b: &mut Bencher) {
-    let mut rng = Pcg32::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg32::from_rng(&mut thread_rng());
     b.iter(|| {
         let mut accum = true;
         let mut p = 0.18;
@@ -46,7 +46,7 @@ fn misc_gen_bool_var(b: &mut Bencher) {
 
 #[bench]
 fn misc_gen_ratio_const(b: &mut Bencher) {
-    let mut rng = Pcg32::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg32::from_rng(&mut thread_rng());
     b.iter(|| {
         let mut accum = true;
         for _ in 0..RAND_BENCH_N {
@@ -58,7 +58,7 @@ fn misc_gen_ratio_const(b: &mut Bencher) {
 
 #[bench]
 fn misc_gen_ratio_var(b: &mut Bencher) {
-    let mut rng = Pcg32::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg32::from_rng(&mut thread_rng());
     b.iter(|| {
         let mut accum = true;
         for i in 2..(RAND_BENCH_N as u32 + 2) {
@@ -70,7 +70,7 @@ fn misc_gen_ratio_var(b: &mut Bencher) {
 
 #[bench]
 fn misc_bernoulli_const(b: &mut Bencher) {
-    let mut rng = Pcg32::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg32::from_rng(&mut thread_rng());
     b.iter(|| {
         let d = Bernoulli::new(0.18).unwrap();
         let mut accum = true;
@@ -83,7 +83,7 @@ fn misc_bernoulli_const(b: &mut Bencher) {
 
 #[bench]
 fn misc_bernoulli_var(b: &mut Bencher) {
-    let mut rng = Pcg32::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg32::from_rng(&mut thread_rng());
     b.iter(|| {
         let mut accum = true;
         let mut p = 0.18;
@@ -99,7 +99,7 @@ fn misc_bernoulli_var(b: &mut Bencher) {
 #[bench]
 fn gen_1kb_u16_iter_repeat(b: &mut Bencher) {
     use core::iter;
-    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng());
     b.iter(|| {
         let v: Vec<u16> = iter::repeat(()).map(|()| rng.random()).take(512).collect();
         v
@@ -109,7 +109,7 @@ fn gen_1kb_u16_iter_repeat(b: &mut Bencher) {
 
 #[bench]
 fn gen_1kb_u16_sample_iter(b: &mut Bencher) {
-    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng());
     b.iter(|| {
         let v: Vec<u16> = Standard.sample_iter(&mut rng).take(512).collect();
         v
@@ -119,7 +119,7 @@ fn gen_1kb_u16_sample_iter(b: &mut Bencher) {
 
 #[bench]
 fn gen_1kb_u16_gen_array(b: &mut Bencher) {
-    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng());
     b.iter(|| {
         // max supported array length is 32!
         let v: [[u16; 32]; 16] = rng.random();
@@ -130,7 +130,7 @@ fn gen_1kb_u16_gen_array(b: &mut Bencher) {
 
 #[bench]
 fn gen_1kb_u16_fill(b: &mut Bencher) {
-    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng());
     let mut buf = [0u16; 512];
     b.iter(|| {
         rng.fill(&mut buf[..]);
@@ -142,7 +142,7 @@ fn gen_1kb_u16_fill(b: &mut Bencher) {
 #[bench]
 fn gen_1kb_u64_iter_repeat(b: &mut Bencher) {
     use core::iter;
-    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng());
     b.iter(|| {
         let v: Vec<u64> = iter::repeat(()).map(|()| rng.random()).take(128).collect();
         v
@@ -152,7 +152,7 @@ fn gen_1kb_u64_iter_repeat(b: &mut Bencher) {
 
 #[bench]
 fn gen_1kb_u64_sample_iter(b: &mut Bencher) {
-    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng());
     b.iter(|| {
         let v: Vec<u64> = Standard.sample_iter(&mut rng).take(128).collect();
         v
@@ -162,7 +162,7 @@ fn gen_1kb_u64_sample_iter(b: &mut Bencher) {
 
 #[bench]
 fn gen_1kb_u64_gen_array(b: &mut Bencher) {
-    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng());
     b.iter(|| {
         // max supported array length is 32!
         let v: [[u64; 32]; 4] = rng.random();
@@ -173,7 +173,7 @@ fn gen_1kb_u64_gen_array(b: &mut Bencher) {
 
 #[bench]
 fn gen_1kb_u64_fill(b: &mut Bencher) {
-    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng()).unwrap();
+    let mut rng = Pcg64Mcg::from_rng(&mut thread_rng());
     let mut buf = [0u64; 128];
     b.iter(|| {
         rng.fill(&mut buf[..]);