Address feedback

- Use `Rng` bounds in `slice.rs`
- Fixup documentation in `rng.rs`
- Bump `rand` and `rand_pcg` versions

Author: tarcieri

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rand"
-version = "0.10.0-rc.7"
+version = "0.10.0-rc.8"
 authors = ["The Rand Project Developers", "The Rust Project Developers"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rand_pcg"
-version = "0.10.0-rc.6"
+version = "0.10.0-rc.7"
 authors = ["The Rand Project Developers"]
 license = "MIT OR Apache-2.0"
 readme = "README.md"

rand_pcg/Cargo.toml

@@ -10,6 +10,7 @@
 
 use core::num::NonZeroUsize;
 
+use crate::Rng;
 use crate::distr::Distribution;
 use crate::distr::uniform::{UniformSampler, UniformUsize};
 #[cfg(feature = "alloc")]
@@ -83,7 +84,7 @@ impl<'a, T> Choose<'a, T> {
 }
 
 impl<'a, T> Distribution<&'a T> for Choose<'a, T> {
-    fn sample<R: crate::RngExt + ?Sized>(&self, rng: &mut R) -> &'a T {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> &'a T {
         let idx = self.range.sample(rng);
 
         debug_assert!(
@@ -120,12 +121,7 @@ impl std::error::Error for Empty {}
 
 #[cfg(feature = "alloc")]
 impl super::SampleString for Choose<'_, char> {
-    fn append_string<R: crate::RngExt + ?Sized>(
-        &self,
-        rng: &mut R,
-        string: &mut String,
-        len: usize,
-    ) {
+    fn append_string<R: Rng + ?Sized>(&self, rng: &mut R, string: &mut String, len: usize) {
         // Get the max char length to minimize extra space.
         // Limit this check to avoid searching for long slice.
         let max_char_len = if self.slice.len() < 200 {

src/distr/slice.rs

@@ -21,19 +21,17 @@ use rand_core::Rng;
 /// (Number) Generators. This trait, `Rng`, provides a user-level interface on
 /// RNGs. It is implemented automatically for any `R: Rng`.
 ///
-/// This trait must usually be brought into scope via `use rand::Rng;` or
+/// This trait must usually be brought into scope via `use rand::RngExt;` or
 /// `use rand::prelude::*;`.
 ///
 /// # Generic usage
 ///
 /// The basic pattern is `fn foo<R: Rng + ?Sized>(rng: &mut R)`. Some
 /// things are worth noting here:
 ///
-/// - Since `Rng: Rng` and every `Rng` implements `Rng`, it makes no
-///   difference whether we use `R: Rng` or `R: Rng`.
-/// - The `+ ?Sized` un-bounding allows functions to be called directly on
-///   type-erased references; i.e. `foo(r)` where `r: &mut dyn Rng`. Without
-///   this it would be necessary to write `foo(&mut r)`.
+/// - Since `RngExt: Rng` and every `RngExt` implements `Rng`, it makes no
+///   difference whether we use `R: Rng` or `R: RngExt` for `R: Sized`.
+/// - Only `Rng` is dyn safe, supporting `&mut dyn Rng` and `R: Rng + ?Sized`.
 ///
 /// An alternative pattern is possible: `fn foo<R: Rng>(rng: R)`. This has some
 /// trade-offs. It allows the argument to be consumed directly without a `&mut`