Struct UnwrapErr 

pub struct UnwrapErr<R>(pub R)
where
    R: TryRng;

Wrapper around TryRng implementation which implements Rng by panicking on potential errors.

Examples

fn with_try_rng<R: TryRng>(mut rng: R) {
    // rng does not impl Rng:
    let _ = rng.try_next_u32(); // okay
    // let _ = rng.next_u32(); // error

    // An adapter borrowing rng:
    let _ = UnwrapErr(&mut rng).next_u32();

    // An adapter moving rng:
    let mut rng = UnwrapErr(rng);
    let _ = rng.next_u32();
}

fn call_with_unsized_try_rng<R: TryRng + ?Sized>(rng: &mut R) {
    // R is unsized, thus we must use &mut R:
    let mut rng = UnwrapErr(rng);
    let _ = rng.next_u32();
}

Tuple Fields

0: R

Implementations

impl<'r, R> UnwrapErr<&'r mut R>

where R: TryRng + ?Sized,

pub fn re<'b>(&'b mut self) -> UnwrapErr<&'b mut R>

where 'r: 'b,

Reborrow with a new lifetime

Rust allows references like &T or &mut T to be “reborrowed” through coercion: essentially, the pointer is copied under a new, shorter, lifetime. Until rfcs#1403 lands, reborrows on user types require a method call.

Trait Implementations

impl<R> Clone for UnwrapErr<R>

where R: Clone + TryRng,

fn clone(&self) -> UnwrapErr<R>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<R> Debug for UnwrapErr<R>

where R: Debug + TryRng,

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<R> Default for UnwrapErr<R>

where R: Default + TryRng,

fn default() -> UnwrapErr<R>

Returns the “default value” for a type.

impl<R> Hash for UnwrapErr<R>

where R: Hash + TryRng,

fn hash<__H>(&self, state: &mut __H)

where __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<R> PartialEq for UnwrapErr<R>

where R: PartialEq + TryRng,

fn eq(&self, other: &UnwrapErr<R>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<R> TryRng for UnwrapErr<R>

where R: TryRng,

type Error = Infallible

The type returned in the event of a RNG error.

fn try_next_u32(&mut self) -> Result<u32, <UnwrapErr<R> as TryRng>::Error>

Return the next random u32.

fn try_next_u64(&mut self) -> Result<u64, <UnwrapErr<R> as TryRng>::Error>

Return the next random u64.

fn try_fill_bytes( &mut self, dst: &mut [u8], ) -> Result<(), <UnwrapErr<R> as TryRng>::Error>

Fill dst entirely with random data.

impl<R> Copy for UnwrapErr<R>

where R: Copy + TryRng,

impl<R> Eq for UnwrapErr<R>

where R: Eq + TryRng,

impl<R> StructuralPartialEq for UnwrapErr<R>

where R: TryRng,

impl<R> TryCryptoRng for UnwrapErr<R>

where R: TryCryptoRng,