adds a Field::try_from_rng method

CHANGELOG.md

@@ -13,6 +13,8 @@ and this library adheres to Rust's notion of
 - `ff::Field::random(rng: impl RngCore) -> Self` has been changed back to
   `Field::random<R: RngCore + ?Sized>(rng: &mut R) -> Self`, to enable passing a
   trait object as the RNG.
+- `ff::Field::try_from_rng` is a new trait method that must be implemented by
+  downstreams. `Field::random` now has a default implementation that calls it.
 
 ### Removed
 - `derive_bits` feature flag (use `bits` instead).

ff_derive/src/lib.rs

@@ -1267,12 +1267,12 @@ fn prime_field_impl(
             const ONE: Self = R;
 
             /// Computes a uniformly random element using rejection sampling.
-            fn random<R: ::ff::derive::rand_core::RngCore + ?Sized>(rng: &mut R) -> Self {
+            fn try_from_rng<R: ::ff::derive::rand_core::TryRngCore + ?Sized>(rng: &mut R) -> ::core::result::Result<Self, R::Error> {
                 loop {
                     let mut tmp = {
                         let mut repr = [0u64; #limbs];
                         for i in 0..#limbs {
-                            repr[i] = rng.next_u64();
+                            repr[i] = rng.try_next_u64()?;
                         }
                         #name(repr)
                     };
@@ -1285,7 +1285,7 @@ fn prime_field_impl(
                     tmp.0.as_mut()[#top_limb_index] &= 0xffffffffffffffffu64.checked_shr(REPR_SHAVE_BITS).unwrap_or(0);
 
                     if tmp.is_valid() {
-                        return tmp
+                        return Ok(tmp)
                     }
                 }
             }

src/lib.rs

@@ -25,11 +25,12 @@ pub use bitvec::view::BitViewSized;
 #[cfg(feature = "bits")]
 use bitvec::{array::BitArray, order::Lsb0};
 
+use core::convert::Infallible;
 use core::fmt;
 use core::iter::{Product, Sum};
 use core::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
-use rand_core::RngCore;
+use rand_core::{RngCore, TryRngCore};
 use subtle::{Choice, ConditionallySelectable, ConstantTimeEq, CtOption};
 
 /// Bit representation of a field element.
@@ -75,7 +76,19 @@ pub trait Field:
     const ONE: Self;
 
     /// Returns an element chosen uniformly at random using a user-provided RNG.
-    fn random<R: RngCore + ?Sized>(rng: &mut R) -> Self;
+    fn random<R: RngCore + ?Sized>(rng: &mut R) -> Self {
+        Self::try_from_rng(rng)
+            .map_err(|e: Infallible| e)
+            .expect("Infallible failed")
+
+        // NOTE: once MSRV gets to 1.82 remove the map_err/expect and use
+        // let Ok(out) = Self::try_from_rng(rng);
+        // out
+        // See: https://blog.rust-lang.org/2024/10/17/Rust-1.82.0.html#omitting-empty-types-in-pattern-matching
+    }
+
+    /// Returns an element chosen uniformly at random using a user-provided RNG.
+    fn try_from_rng<R: TryRngCore + ?Sized>(rng: &mut R) -> Result<Self, R::Error>;
 
     /// Returns true iff this element is zero.
     fn is_zero(&self) -> Choice {

tests/derive.rs

@@ -33,6 +33,7 @@ mod full_limbs {
         use ff::Field;
 
         let _ = F384p::random(&mut rand::rng());
+        let _ = F384p::try_from_rng(&mut rand::rngs::OsRng).unwrap();
     }
 }