Add fn rand::make_rng

CHANGELOG.md

@@ -28,6 +28,7 @@ You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.
 - Add fns `IndexedRandom::choose_iter`, `choose_weighted_iter` ([#1632])
 - Pub export `Xoshiro128PlusPlus`, `Xoshiro256PlusPlus` prngs ([#1649])
 - Pub export `ChaCha8Rng`, `ChaCha12Rng`, `ChaCha20Rng` behind `chacha` feature ([#1659])
+- Fn `rand::make_rng() -> R where R: SeedableRng` ([#1734])
 
 ### Removals
 - Removed `ReseedingRng` ([#1722])
@@ -50,6 +51,7 @@ You may also find the [Upgrade Guide](https://rust-random.github.io/book/update.
 [#1717]: https://github.com/rust-random/rand/pull/1717
 [#1722]: https://github.com/rust-random/rand/pull/1722
 [#1732]: https://github.com/rust-random/rand/pull/1732
+[#1734]: https://github.com/rust-random/rand/pull/1734
 
 ## [0.9.2] - 2025-07-20
 

benches/benches/array.rs

@@ -26,31 +26,31 @@ pub fn bench(c: &mut Criterion) {
 
     g.bench_function("u16_iter_repeat", |b| {
         use core::iter;
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| {
             let v: Vec<u16> = iter::repeat(()).map(|()| rng.random()).take(512).collect();
             v
         });
     });
 
     g.bench_function("u16_sample_iter", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| {
             let v: Vec<u16> = StandardUniform.sample_iter(&mut rng).take(512).collect();
             v
         });
     });
 
     g.bench_function("u16_gen_array", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| {
             let v: [u16; 512] = rng.random();
             v
         });
     });
 
     g.bench_function("u16_fill", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         let mut buf = [0u16; 512];
         b.iter(|| {
             rng.fill(&mut buf[..]);
@@ -60,31 +60,31 @@ pub fn bench(c: &mut Criterion) {
 
     g.bench_function("u64_iter_repeat", |b| {
         use core::iter;
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| {
             let v: Vec<u64> = iter::repeat(()).map(|()| rng.random()).take(128).collect();
             v
         });
     });
 
     g.bench_function("u64_sample_iter", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| {
             let v: Vec<u64> = StandardUniform.sample_iter(&mut rng).take(128).collect();
             v
         });
     });
 
     g.bench_function("u64_gen_array", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| {
             let v: [u64; 128] = rng.random();
             v
         });
     });
 
     g.bench_function("u64_fill", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         let mut buf = [0u64; 128];
         b.iter(|| {
             rng.fill(&mut buf[..]);

benches/benches/bool.rs

@@ -27,41 +27,41 @@ pub fn bench(c: &mut Criterion) {
     g.measurement_time(core::time::Duration::from_millis(1000));
 
     g.bench_function("standard", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         b.iter(|| rng.sample::<bool, _>(rand::distr::StandardUniform))
     });
 
     g.bench_function("const", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         b.iter(|| rng.random_bool(0.18))
     });
 
     g.bench_function("var", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         let p = rng.random();
         b.iter(|| rng.random_bool(p))
     });
 
     g.bench_function("ratio_const", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         b.iter(|| rng.random_ratio(2, 3))
     });
 
     g.bench_function("ratio_var", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         let d = rng.random_range(1..=100);
         let n = rng.random_range(0..=d);
         b.iter(|| rng.random_ratio(n, d));
     });
 
     g.bench_function("bernoulli_const", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         let d = Bernoulli::new(0.18).unwrap();
         b.iter(|| rng.sample(d))
     });
 
     g.bench_function("bernoulli_var", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         let p = rng.random();
         let d = Bernoulli::new(p).unwrap();
         b.iter(|| rng.sample(d))

benches/benches/generators.rs

@@ -38,15 +38,15 @@ pub fn random_bytes(c: &mut Criterion) {
         });
     }
 
-    bench(&mut g, "pcg32", Pcg32::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64", Pcg64::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64mcg", Pcg64Mcg::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64dxsm", Pcg64Dxsm::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha8", ChaCha8Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha12", ChaCha12Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha20", ChaCha20Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "std", StdRng::from_rng(&mut rand::rng()));
-    bench(&mut g, "small", SmallRng::from_rng(&mut rand::rng()));
+    bench(&mut g, "pcg32", rand::make_rng::<Pcg32>());
+    bench(&mut g, "pcg64", rand::make_rng::<Pcg64>());
+    bench(&mut g, "pcg64mcg", rand::make_rng::<Pcg64Mcg>());
+    bench(&mut g, "pcg64dxsm", rand::make_rng::<Pcg64Dxsm>());
+    bench(&mut g, "chacha8", rand::make_rng::<ChaCha8Rng>());
+    bench(&mut g, "chacha12", rand::make_rng::<ChaCha12Rng>());
+    bench(&mut g, "chacha20", rand::make_rng::<ChaCha20Rng>());
+    bench(&mut g, "std", rand::make_rng::<StdRng>());
+    bench(&mut g, "small", rand::make_rng::<SmallRng>());
     bench(&mut g, "os", UnwrapErr(SysRng));
     bench(&mut g, "thread", rand::rng());
 
@@ -66,15 +66,15 @@ pub fn random_u32(c: &mut Criterion) {
         });
     }
 
-    bench(&mut g, "pcg32", Pcg32::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64", Pcg64::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64mcg", Pcg64Mcg::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64dxsm", Pcg64Dxsm::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha8", ChaCha8Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha12", ChaCha12Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha20", ChaCha20Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "std", StdRng::from_rng(&mut rand::rng()));
-    bench(&mut g, "small", SmallRng::from_rng(&mut rand::rng()));
+    bench(&mut g, "pcg32", rand::make_rng::<Pcg32>());
+    bench(&mut g, "pcg64", rand::make_rng::<Pcg64>());
+    bench(&mut g, "pcg64mcg", rand::make_rng::<Pcg64Mcg>());
+    bench(&mut g, "pcg64dxsm", rand::make_rng::<Pcg64Dxsm>());
+    bench(&mut g, "chacha8", rand::make_rng::<ChaCha8Rng>());
+    bench(&mut g, "chacha12", rand::make_rng::<ChaCha12Rng>());
+    bench(&mut g, "chacha20", rand::make_rng::<ChaCha20Rng>());
+    bench(&mut g, "std", rand::make_rng::<StdRng>());
+    bench(&mut g, "small", rand::make_rng::<SmallRng>());
     bench(&mut g, "os", UnwrapErr(SysRng));
     bench(&mut g, "thread", rand::rng());
 
@@ -94,15 +94,15 @@ pub fn random_u64(c: &mut Criterion) {
         });
     }
 
-    bench(&mut g, "pcg32", Pcg32::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64", Pcg64::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64mcg", Pcg64Mcg::from_rng(&mut rand::rng()));
-    bench(&mut g, "pcg64dxsm", Pcg64Dxsm::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha8", ChaCha8Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha12", ChaCha12Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "chacha20", ChaCha20Rng::from_rng(&mut rand::rng()));
-    bench(&mut g, "std", StdRng::from_rng(&mut rand::rng()));
-    bench(&mut g, "small", SmallRng::from_rng(&mut rand::rng()));
+    bench(&mut g, "pcg32", rand::make_rng::<Pcg32>());
+    bench(&mut g, "pcg64", rand::make_rng::<Pcg64>());
+    bench(&mut g, "pcg64mcg", rand::make_rng::<Pcg64Mcg>());
+    bench(&mut g, "pcg64dxsm", rand::make_rng::<Pcg64Dxsm>());
+    bench(&mut g, "chacha8", rand::make_rng::<ChaCha8Rng>());
+    bench(&mut g, "chacha12", rand::make_rng::<ChaCha12Rng>());
+    bench(&mut g, "chacha20", rand::make_rng::<ChaCha20Rng>());
+    bench(&mut g, "std", rand::make_rng::<StdRng>());
+    bench(&mut g, "small", rand::make_rng::<SmallRng>());
     bench(&mut g, "os", UnwrapErr(SysRng));
     bench(&mut g, "thread", rand::rng());
 
@@ -116,7 +116,7 @@ pub fn init_gen(c: &mut Criterion) {
 
     fn bench<R: SeedableRng>(g: &mut BenchmarkGroup<WallTime>, name: &str) {
         g.bench_function(name, |b| {
-            let mut rng = Pcg32::from_rng(&mut rand::rng());
+            let mut rng: Pcg32 = rand::make_rng();
             b.iter(|| R::from_rng(&mut rng));
         });
     }
@@ -141,7 +141,7 @@ pub fn init_from_u64(c: &mut Criterion) {
 
     fn bench<R: SeedableRng>(g: &mut BenchmarkGroup<WallTime>, name: &str) {
         g.bench_function(name, |b| {
-            let mut rng = Pcg32::from_rng(&mut rand::rng());
+            let mut rng: Pcg32 = rand::make_rng();
             let seed = rng.random();
             b.iter(|| R::seed_from_u64(black_box(seed)));
         });
@@ -170,7 +170,7 @@ pub fn init_from_seed(c: &mut Criterion) {
         rand::distr::StandardUniform: Distribution<<R as SeedableRng>::Seed>,
     {
         g.bench_function(name, |b| {
-            let mut rng = Pcg32::from_rng(&mut rand::rng());
+            let mut rng: Pcg32 = rand::make_rng();
             let seed = rng.random();
             b.iter(|| R::from_seed(black_box(seed.clone())));
         });

benches/benches/seq_choose.rs

@@ -20,7 +20,7 @@ criterion_main!(benches);
 
 pub fn bench(c: &mut Criterion) {
     c.bench_function("seq_slice_choose_1_of_100", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         let mut buf = [0i32; 100];
         rng.fill(&mut buf);
         let x = black_box(&mut buf);
@@ -32,7 +32,7 @@ pub fn bench(c: &mut Criterion) {
     for (amount, len) in lens {
         let name = format!("seq_slice_sample_{amount}_of_{len}");
         c.bench_function(name.as_str(), |b| {
-            let mut rng = Pcg32::from_rng(&mut rand::rng());
+            let mut rng: Pcg32 = rand::make_rng();
             let mut buf = [0i32; 1000];
             rng.fill(&mut buf);
             let x = black_box(&buf[..len]);
@@ -56,7 +56,7 @@ pub fn bench(c: &mut Criterion) {
     for (amount, len) in lens {
         let name = format!("seq_slice_sample_weighted_{amount}_of_{len}");
         c.bench_function(name.as_str(), |b| {
-            let mut rng = Pcg32::from_rng(&mut rand::rng());
+            let mut rng: Pcg32 = rand::make_rng();
             let mut buf = [0i32; 1000];
             rng.fill(&mut buf);
             let x = black_box(&buf[..len]);
@@ -78,15 +78,15 @@ pub fn bench(c: &mut Criterion) {
     }
 
     c.bench_function("seq_iter_sample_10_of_100", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         let mut buf = [0i32; 100];
         rng.fill(&mut buf);
         let x = black_box(&buf);
         b.iter(|| x.iter().cloned().sample(&mut rng, 10))
     });
 
     c.bench_function("seq_iter_sample_fill_10_of_100", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         let mut buf = [0i32; 100];
         rng.fill(&mut buf);
         let x = black_box(&buf);

benches/benches/shuffle.rs

@@ -20,7 +20,7 @@ criterion_main!(benches);
 
 pub fn bench(c: &mut Criterion) {
     c.bench_function("seq_shuffle_100", |b| {
-        let mut rng = Pcg32::from_rng(&mut rand::rng());
+        let mut rng: Pcg32 = rand::make_rng();
         let mut buf = [0i32; 100];
         rng.fill(&mut buf);
         let x = black_box(&mut buf);

benches/benches/simd.rs

@@ -30,47 +30,47 @@ pub fn simd(c: &mut Criterion) {
     let mut g = c.benchmark_group("random_simd");
 
     g.bench_function("u128", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<u128>());
     });
 
     g.bench_function("m128i", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<core::arch::x86_64::__m128i>());
     });
 
     g.bench_function("m256i", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<core::arch::x86_64::__m256i>());
     });
 
     g.bench_function("m512i", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<core::arch::x86_64::__m512i>());
     });
 
     g.bench_function("u64x2", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<core::simd::u64x2>());
     });
 
     g.bench_function("u32x4", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<core::simd::u64x4>());
     });
 
     g.bench_function("u32x8", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<core::simd::u8x32>());
     });
 
     g.bench_function("u16x8", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<core::simd::u8x32>());
     });
 
     g.bench_function("u8x16", |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
         b.iter(|| rng.random::<core::simd::u8x32>());
     });
 }

benches/benches/standard.rs

@@ -26,7 +26,7 @@ where
 {
     g.throughput(criterion::Throughput::Bytes(core::mem::size_of::<T>() as u64));
     g.bench_function(name, |b| {
-        let mut rng = Pcg64Mcg::from_rng(&mut rand::rng());
+        let mut rng: Pcg64Mcg = rand::make_rng();
 
         b.iter(|| rng.sample::<T, _>(D::default()));
     });

benches/benches/uniform.rs

@@ -59,7 +59,7 @@ macro_rules! sample {
 
     ($R:ty, $T:ty, $U:ty, $len:tt, $g:expr) => {
         $g.bench_function(BenchmarkId::new(stringify!($R), "single"), |b| {
-            let mut rng = <$R>::from_rng(&mut rand::rng());
+            let mut rng: $R = rand::make_rng();
             let range = sample!(@range $T, $U, $len, rng);
             let low = sample!(@MIN $T, $len);
             let high = sample!(@wrapping_add low, range, $len);
@@ -68,7 +68,7 @@ macro_rules! sample {
         });
 
         $g.bench_function(BenchmarkId::new(stringify!($R), "distr"), |b| {
-            let mut rng = <$R>::from_rng(&mut rand::rng());
+            let mut rng: $R = rand::make_rng();
             let range = sample!(@range $T, $U, $len, rng);
             let low = sample!(@MIN $T, $len);
             let high = sample!(@wrapping_add low, range, $len);

benches/benches/uniform_float.rs

@@ -27,7 +27,7 @@ const N_RESAMPLES: usize = 10_000;
 macro_rules! single_random {
     ($R:ty, $T:ty, $g:expr) => {
         $g.bench_function(BenchmarkId::new(stringify!($T), stringify!($R)), |b| {
-            let mut rng = <$R>::from_rng(&mut rand::rng());
+            let mut rng: $R = rand::make_rng();
             let (mut low, mut high);
             loop {
                 low = <$T>::from_bits(rng.random());
@@ -63,7 +63,7 @@ fn single_random(c: &mut Criterion) {
 macro_rules! distr_random {
     ($R:ty, $T:ty, $g:expr) => {
         $g.bench_function(BenchmarkId::new(stringify!($T), stringify!($R)), |b| {
-            let mut rng = <$R>::from_rng(&mut rand::rng());
+            let mut rng: $R = rand::make_rng();
             let dist = loop {
                 let low = <$T>::from_bits(rng.random());
                 let high = <$T>::from_bits(rng.random());