Adjust Infallible import; adjust RngExt => Rng bounds

Author: tarcieri

rand_pcg/src/pcg128.rs

@@ -13,8 +13,8 @@
 // This is the default multiplier used by PCG for 128-bit state.
 const MULTIPLIER: u128 = 0x2360_ED05_1FC6_5DA4_4385_DF64_9FCC_F645;
 
-use core::{convert::Infallible, fmt};
-use rand_core::{SeedableRng, TryRng, utils};
+use core::fmt;
+use rand_core::{Infallible, SeedableRng, TryRng, utils};
 #[cfg(feature = "serde")]
 use serde::{Deserialize, Serialize};
 

src/distr/integer.rs

@@ -8,8 +8,8 @@
 
 //! The implementations of the `StandardUniform` distribution for integer types.
 
-use crate::RngExt;
 use crate::distr::{Distribution, StandardUniform};
+use crate::{Rng, RngExt};
 #[cfg(all(target_arch = "x86", feature = "simd_support"))]
 use core::arch::x86::__m512i;
 #[cfg(target_arch = "x86")]
@@ -27,35 +27,35 @@ use core::simd::*;
 
 impl Distribution<u8> for StandardUniform {
     #[inline]
-    fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> u8 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8 {
         rng.next_u32() as u8
     }
 }
 
 impl Distribution<u16> for StandardUniform {
     #[inline]
-    fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> u16 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u16 {
         rng.next_u32() as u16
     }
 }
 
 impl Distribution<u32> for StandardUniform {
     #[inline]
-    fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> u32 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u32 {
         rng.next_u32()
     }
 }
 
 impl Distribution<u64> for StandardUniform {
     #[inline]
-    fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> u64 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u64 {
         rng.next_u64()
     }
 }
 
 impl Distribution<u128> for StandardUniform {
     #[inline]
-    fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> u128 {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u128 {
         // Use LE; we explicitly generate one value before the next.
         let x = u128::from(rng.next_u64());
         let y = u128::from(rng.next_u64());
@@ -67,7 +67,7 @@ macro_rules! impl_int_from_uint {
     ($ty:ty, $uty:ty) => {
         impl Distribution<$ty> for StandardUniform {
             #[inline]
-            fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> $ty {
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
                 rng.random::<$uty>() as $ty
             }
         }
@@ -83,7 +83,7 @@ impl_int_from_uint! { i128, u128 }
 macro_rules! impl_nzint {
     ($ty:ty, $new:path) => {
         impl Distribution<$ty> for StandardUniform {
-            fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> $ty {
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> $ty {
                 loop {
                     if let Some(nz) = $new(rng.random()) {
                         break nz;
@@ -109,7 +109,7 @@ impl_nzint!(NonZeroI128, NonZeroI128::new);
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 impl Distribution<__m128i> for StandardUniform {
     #[inline]
-    fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> __m128i {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> __m128i {
         // NOTE: It's tempting to use the u128 impl here, but confusingly this
         // results in different code (return via rdx, r10 instead of rax, rdx
         // with u128 impl) and is much slower (+130 time).
@@ -126,7 +126,7 @@ impl Distribution<__m128i> for StandardUniform {
 #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
 impl Distribution<__m256i> for StandardUniform {
     #[inline]
-    fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> __m256i {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> __m256i {
         let mut buf = [0_u8; core::mem::size_of::<__m256i>()];
         rng.fill_bytes(&mut buf);
         // x86 is little endian so no need for conversion
@@ -142,7 +142,7 @@ impl Distribution<__m256i> for StandardUniform {
 ))]
 impl Distribution<__m512i> for StandardUniform {
     #[inline]
-    fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> __m512i {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> __m512i {
         let mut buf = [0_u8; core::mem::size_of::<__m512i>()];
         rng.fill_bytes(&mut buf);
         // x86 is little endian so no need for conversion
@@ -164,7 +164,7 @@ macro_rules! simd_impl {
             LaneCount<LANES>: SupportedLaneCount,
         {
             #[inline]
-            fn sample<R: RngExt + ?Sized>(&self, rng: &mut R) -> Simd<$ty, LANES> {
+            fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Simd<$ty, LANES> {
                 let mut vec = Simd::default();
                 rng.fill(vec.as_mut_array().as_mut_slice());
                 vec