Updates for rand v0.10

Author: dhardy

src/guide-data.md

@@ -1,7 +1,7 @@
 # Random data
 
 ```rust
-# use rand::RngCore;
+# use rand::Rng;
 # fn main() {
 // get some random data:
 let mut data = [0u8; 8];

src/guide-dist.md

@@ -94,7 +94,7 @@ Lets go over the distributions by type:
 -   For enums, you have to implement uniform sampling yourself. For example, you
     could use the following approach:
     ```rust,noplayground
-    # use rand::{Rng, distr::{Distribution, StandardUniform}};
+    # use rand::{Rng, RngExt, distr::{Distribution, StandardUniform}};
     pub enum Food {
         Burger,
         Pizza,

src/guide-gen.md

@@ -7,15 +7,15 @@ This section concerns theory; see also the chapter on
 [random number generators](guide-rngs.md).
 
 ```rust
-use rand::{Rng, SeedableRng};
+use rand::{RngExt, SeedableRng};
 
 # fn main() {
 // prepare a non-deterministic random number generator:
 let mut rng = rand::rng();
 println!("{}", rng.random::<i32>()); // prints an unknown value
 
 // prepare a deterministic generator:
-let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(123);
+let mut rng = rand::rngs::ChaCha8Rng::seed_from_u64(123);
 println!("{}", rng.random::<i32>()); // prints -416273517
 # }
 ```

src/guide-parallel.md

@@ -108,7 +108,7 @@ non-deterministic simulation too.
 
 ```rust
 use rand::distr::{Distribution, Uniform};
-use rand_chacha::{rand_core::SeedableRng, ChaCha8Rng};
+use rand::{SeedableRng, rngs::ChaCha8Rng};
 use rayon::prelude::*;
 
 static SEED: u64 = 0;

src/guide-rngs.md

@@ -247,9 +247,17 @@ seeded with a secure random key. Should the key be known or guessable, all
 output of the CSPRNG is easy to guess. This implies that the seed should
 come from a trusted source; usually either the OS or another CSPRNG. For this
 purpose, we recommend using the [`getrandom`] crate which interfaces the OS's
-secure random interface. [`SeedableRng::from_os_rng`] is a wrapper around
-[`getrandom`] for convenience. Alternatively, using a user-space CSPRNG such as
-[`ThreadRng`] for seeding should be sufficient.
+secure random interface. Alternatively, using a user-space CSPRNG such as
+[`rand::make_rng()`] or [`ThreadRng`] for seeding should be sufficient. In code:
+```rust
+use rand::{rngs::ChaCha12Rng, rngs::SysRng, SeedableRng};
+
+/// Seed explicitly from SysRng:
+let mut rng1 = ChaCha12Rng::try_from_rng(&mut SysRng).unwrap();
+
+/// Seed from ThreadRng (or SysRng if ThreadRng is not available):
+let mut rng2: ChaCha12Rng = rand::make_rng();
+```
 
 Further, it should be obvious that the internal state of a CSPRNG must be
 kept secret. With that in mind, our implementations do not provide direct
@@ -335,5 +343,5 @@ by P. Hellekalek.
 [NIST]: https://www.nist.gov/
 [ECRYPT]: http://www.ecrypt.eu.org/
 [`getrandom`]: https://docs.rs/getrandom/
-[`SeedableRng::from_os_rng`]: https://docs.rs/rand/latest/rand/trait.SeedableRng.html#method.from_os_rng
 [zeroize]: https://crates.io/crates/zeroize
+[`rand::make_rng()`]: https://docs.rs/rand/latest/rand/fn.make_rng.html

src/guide-seeding.md

@@ -25,14 +25,14 @@ PRNGs may be seeded directly from such a value with [`SeedableRng::from_seed`].
 
 ### Fresh entropy
 
-Using a fresh seed (direct from the OS) is easy using [`SeedableRng::from_os_rng`]:
+Using a fresh seed is easy using [`rand::make_rng()`]:
 
 ```rust,editable
 use rand::prelude::*;
-use rand_chacha::ChaCha20Rng;
+use rand::rngs::ChaCha20Rng;
 
 fn main() {
-    let mut rng = ChaCha20Rng::from_os_rng();
+    let mut rng: ChaCha20Rng = rand::make_rng();
     println!("{}", rng.random_range(0..100));
 }
 ```
@@ -58,7 +58,7 @@ little bit more explicit:
 
 ```rust,editable
 use rand::prelude::*;
-use rand_chacha::ChaCha8Rng;
+use rand::rngs::ChaCha8Rng;
 
 fn main() {
     let mut seed: <ChaCha8Rng as SeedableRng>::Seed = Default::default();
@@ -87,7 +87,7 @@ number while providing good bit-avalanche (so that two similar numbers such as
 
 ```rust,editable
 use rand::prelude::*;
-use rand_chacha::ChaCha8Rng;
+use rand::rngs::ChaCha8Rng;
 
 fn main() {
     let mut rng = ChaCha8Rng::seed_from_u64(2);
@@ -143,7 +143,7 @@ function such as Argon2 must be used.
 [`SeedableRng::from_seed`]: https://docs.rs/rand_core/latest/rand_core/trait.SeedableRng.html#tymethod.from_seed
 [`SeedableRng::from_rng`]: https://docs.rs/rand_core/latest/rand_core/trait.SeedableRng.html#method.from_rng
 [`SeedableRng::seed_from_u64`]: https://docs.rs/rand_core/latest/rand_core/trait.SeedableRng.html#method.seed_from_u64
-[`SeedableRng::from_os_rng`]: https://docs.rs/rand_core/latest/rand_core/trait.SeedableRng.html#method.from_os_rng
 [`XorShiftRng`]: https://docs.rs/rand_xorshift/latest/rand_xorshift/struct.XorShiftRng.html
 [`ChaCha8Rng`]: https://docs.rs/rand_chacha/latest/rand_chacha/struct.ChaCha8Rng.html
 [`rand_seeder`]: https://github.com/rust-random/seeder/
+[`rand::make_rng()`]: https://docs.rs/rand/latest/rand/fn.make_rng.html

src/guide-test-fn-rng.md

@@ -3,9 +3,9 @@
 Occasionally a function that uses random number generators might need to be tested. For functions that need to be tested with test vectors, the following approach might be adapted:
 
 ```rust
-use rand::{TryCryptoRng, rngs::OsRng};
+use rand::{TryCryptoRng, rngs::SysRng};
 
-pub struct CryptoOperations<R: TryCryptoRng = OsRng> {
+pub struct CryptoOperations<R: TryCryptoRng = SysRng> {
     rng: R
 }
 
@@ -30,7 +30,7 @@ impl<R: TryCryptoRng> CryptoOperations<R> {
 }
 
 fn main() {
-    let rng = OsRng;
+    let rng = SysRng;
     let mut crypto_ops = <CryptoOperations>::new(rng);
 
     let mut secret: [u8; 8] = *b"\x00\x01\x02\x03\x04\x05\x06\x07";

src/guide-values.md

@@ -38,7 +38,7 @@ Finally, it has a function to sample from arbitrary distributions:
 Examples:
 
 ```rust
-use rand::Rng;
+use rand::RngExt;
 # fn main() {
 let mut rng = rand::rng();
 
@@ -90,7 +90,7 @@ according to reasonable logic:
 
 Given that, we can implement the [`StandardUniform`] distribution for our own types:
 ```rust
-use rand::Rng;
+use rand::{Rng, RngExt};
 use rand::distr::{Distribution, StandardUniform, Uniform};
 use std::f64::consts::TAU; // = 2π
 

src/quick-start.md

@@ -81,10 +81,10 @@ See the [RNGs] section for more RNGs, but avoid `SmallRng` and `StdRng` if you
 care about reproducible results.
 
 ```rust,editable
-use rand::{Rng, SeedableRng};
+use rand::{rngs::ChaCha8Rng, RngExt, SeedableRng};
 
 fn main() {
-    let mut rng = rand_chacha::ChaCha8Rng::seed_from_u64(10);
+    let mut rng = ChaCha8Rng::seed_from_u64(10);
     println!("Random f32: {}", rng.random::<f32>());
 }
 ```

src/update-0.10.md

@@ -26,7 +26,7 @@ Users of `rand` will often need to import `rand::RngExt` may need to migrate fro
 
 `rand_core::OsRng` has been replaced with `getrandom::SysRng` (also available as `rand::rngs::SysRng`).
 
-The methods `SeedableRng::from_os_rng` and `try_from_os_rng` have thus been removed. `rand::make_rng()` is provided as a partial replacement; otherwise use `SomeRng::try_from_rng(&mut SysRng).unwrap()`.
+The methods `SeedableRng::from_os_rng` and `try_from_os_rng` have thus been removed. [`rand::make_rng()`] is provided as a partial replacement; otherwise use `SomeRng::try_from_rng(&mut SysRng).unwrap()`.
 
 
 ## PRNGs
@@ -41,10 +41,10 @@ Other PRNG crates have been updated with minimal changes (though this may not re
 
 `StdRng` and `ChaCha{8,12,20}Rng` no longer implement `Clone` or the [serde] traits. This was a deliberate choice to prevent accidental key-stream duplication or persisting to external storage. Note that it remains possible to clone or serialize these RNGs by reconstructing a new instance with the same key, then setting the stream (if applicable) and word position. For example:
 ```rust,editable
-use rand::{rngs::ChaCha8Rng, Rng};
+use rand::{rngs::ChaCha8Rng, Rng, SeedableRng};
 
 let mut rng1: ChaCha8Rng = rand::make_rng();
-let _: u128 = rng1.next_u64();
+let _ = rng1.next_u64();
 
 let mut rng2 = ChaCha8Rng::from_seed(rng1.get_seed());
 rng2.set_stream(rng1.get_stream());
@@ -85,3 +85,4 @@ There are no known value-breaking changes to `rand` in v0.10.
 
 
 [serde]: https://serde.rs/
+[`rand::make_rng()`]: https://docs.rs/rand/latest/rand/fn.make_rng.html