Struct rand::distributions::Alphanumeric

pub struct Alphanumeric;

Sample a u8, uniformly distributed over ASCII letters and numbers: a-z, A-Z and 0-9.

Example

use rand::{Rng, thread_rng};
use rand::distributions::Alphanumeric;

let mut rng = thread_rng();
let chars: String = (0..7).map(|_| rng.sample(Alphanumeric) as char).collect();
println!("Random chars: {}", chars);

The DistString trait provides an easier method of generating a random String, and offers more efficient allocation:

use rand::distributions::{Alphanumeric, DistString};
let string = Alphanumeric.sample_string(&mut rand::thread_rng(), 16);
println!("Random string: {}", string);

Passwords

Users sometimes ask whether it is safe to use a string of random characters as a password. In principle, all RNGs in Rand implementing CryptoRng are suitable as a source of randomness for generating passwords (if they are properly seeded), but it is more conservative to only use randomness directly from the operating system via the getrandom crate, or the corresponding bindings of a crypto library.

When generating passwords or keys, it is important to consider the threat model and in some cases the memorability of the password. This is out of scope of the Rand project, and therefore we defer to the following references:

• Wikipedia article on Password Strength
• Diceware for generating memorable passwords

Trait Implementations

impl Clone for Alphanumeric

fn clone(&self) -> Alphanumeric

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Alphanumeric

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

Formats the value using the given formatter.

impl DistString for Alphanumeric

fn append_string<R: Rng + ?Sized>(
    &self,
    rng: &mut R,
    string: &mut String,
    len: usize
)

Append len random chars to string

fn sample_string<R: Rng + ?Sized>(&self, rng: &mut R, len: usize) -> String

Generate a String of len random chars

impl Distribution<u8> for Alphanumeric

fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> u8

Generate a random value of T, using rng as the source of randomness.

fn sample_iter<R>(self, rng: R) -> DistIter<Self, R, T>where
    R: Rng,
    Self: Sized,

Create an iterator that generates random values of T, using rng as the source of randomness.

fn map<F, S>(self, func: F) -> DistMap<Self, F, T, S>where
    F: Fn(T) -> S,
    Self: Sized,

Create a distribution of values of ‘S’ by mapping the output of Self through the closure F

impl Copy for Alphanumeric