Remove unnececcary ?Sized bounds

Cargo.toml

@@ -81,7 +81,3 @@ harness = false
 [[bench]]
 name = "int"
 harness = false
-
-[patch.crates-io]
-# https://github.com/rust-random/rand/pull/1593
-rand_core = { git = "https://github.com/fjarri/rand.git", branch = "sized" }

src/int/rand.rs

@@ -8,7 +8,7 @@ use super::Uint;
 
 impl<const LIMBS: usize> Random for Int<LIMBS> {
     /// Generate a cryptographically secure random [`Int`].
-    fn random<R: RngCore + ?Sized>(rng: &mut R) -> Self {
+    fn random<R: RngCore>(rng: &mut R) -> Self {
         Self(Uint::random(rng))
     }
 }

src/modular/const_monty_form.rs

@@ -207,7 +207,7 @@ where
     MOD: ConstMontyParams<LIMBS>,
 {
     #[inline]
-    fn random<R: RngCore + ?Sized>(rng: &mut R) -> Self {
+    fn random<R: RngCore>(rng: &mut R) -> Self {
         Self::new(&Uint::random_mod(rng, MOD::MODULUS.as_nz_ref()))
     }
 }

src/odd.rs

@@ -153,7 +153,7 @@ impl PartialOrd<Odd<BoxedUint>> for BoxedUint {
 #[cfg(feature = "rand_core")]
 impl<const LIMBS: usize> Random for Odd<Uint<LIMBS>> {
     /// Generate a random `Odd<Uint<T>>`.
-    fn random<R: RngCore + ?Sized>(rng: &mut R) -> Self {
+    fn random<R: RngCore>(rng: &mut R) -> Self {
         let mut ret = Uint::random(rng);
         ret.limbs[0] |= Limb::ONE;
         Odd(ret)

src/traits.rs

@@ -299,7 +299,7 @@ pub trait Random: Sized {
     /// Generate a random value.
     ///
     /// If `rng` is a CSRNG, the generation is cryptographically secure as well.
-    fn random<R: RngCore + ?Sized>(rng: &mut R) -> Self;
+    fn random<R: RngCore>(rng: &mut R) -> Self;
 }
 
 /// Possible errors of the methods in [`RandomBits`] trait.
@@ -419,7 +419,7 @@ pub trait RandomMod: Sized + Zero {
     /// example, it implements `CryptoRng`), then this is guaranteed not to
     /// leak anything about the output value aside from it being less than
     /// `modulus`.
-    fn random_mod<R: RngCore + ?Sized>(rng: &mut R, modulus: &NonZero<Self>) -> Self;
+    fn random_mod<R: RngCore>(rng: &mut R, modulus: &NonZero<Self>) -> Self;
 
     /// Generate a random number which is less than a given `modulus`.
     ///
@@ -430,7 +430,7 @@ pub trait RandomMod: Sized + Zero {
     /// example, it implements `CryptoRng`), then this is guaranteed not to
     /// leak anything about the output value aside from it being less than
     /// `modulus`.
-    fn try_random_mod<R: TryRngCore + ?Sized>(
+    fn try_random_mod<R: TryRngCore>(
         rng: &mut R,
         modulus: &NonZero<Self>,
     ) -> Result<Self, R::Error>;

src/uint/boxed/rand.rs

@@ -34,13 +34,13 @@ impl RandomBits for BoxedUint {
 }
 
 impl RandomMod for BoxedUint {
-    fn random_mod<R: RngCore + ?Sized>(rng: &mut R, modulus: &NonZero<Self>) -> Self {
+    fn random_mod<R: RngCore>(rng: &mut R, modulus: &NonZero<Self>) -> Self {
         let mut n = BoxedUint::zero_with_precision(modulus.bits_precision());
         let Ok(()) = random_mod_core(rng, &mut n, modulus, modulus.bits());
         n
     }
 
-    fn try_random_mod<R: TryRngCore + ?Sized>(
+    fn try_random_mod<R: TryRngCore>(
         rng: &mut R,
         modulus: &NonZero<Self>,
     ) -> Result<Self, R::Error> {

src/uint/rand.rs

@@ -81,7 +81,7 @@ impl<const LIMBS: usize> RandomBits for Uint<LIMBS> {
 }
 
 impl<const LIMBS: usize> RandomMod for Uint<LIMBS> {
-    fn random_mod<R: RngCore + ?Sized>(rng: &mut R, modulus: &NonZero<Self>) -> Self {
+    fn random_mod<R: RngCore>(rng: &mut R, modulus: &NonZero<Self>) -> Self {
         let mut n = Self::ZERO;
         let Ok(()) = random_mod_core(rng, &mut n, modulus, modulus.bits_vartime());
         n

src/wrapping.rs

@@ -259,7 +259,7 @@ impl<T: fmt::UpperHex> fmt::UpperHex for Wrapping<T> {
 
 #[cfg(feature = "rand_core")]
 impl<T: Random> Random for Wrapping<T> {
-    fn random<R: RngCore + ?Sized>(rng: &mut R) -> Self {
+    fn random<R: RngCore>(rng: &mut R) -> Self {
         Wrapping(Random::random(rng))
     }
 }