Struct `Alphanumeric`

pub struct Alphanumeric;

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

Example

use rand::RngExt;
use rand::distr::Alphanumeric;

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

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

use rand::distr::{Alphanumeric, SampleString};
let string = Alphanumeric.sample_string(&mut rand::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:

Trait Implementations

`impl Clone for Alphanumeric`

fn clone(&self) -> Alphanumeric

`impl Copy for Alphanumeric`

`impl Debug for Alphanumeric`

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

`impl Default for Alphanumeric`

fn default() -> Alphanumeric

`impl Distribution<u8> for Alphanumeric`

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

`impl SampleString for Alphanumeric`

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

`impl Serialize for Alphanumeric`

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where __S: Serializer,

`impl<'de> Deserialize<'de> for Alphanumeric`

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where __D: Deserializer<'de>,

Auto Trait Implementations

`impl Freeze for Alphanumeric`

`impl RefUnwindSafe for Alphanumeric`

`impl Send for Alphanumeric`

`impl Sync for Alphanumeric`

`impl Unpin for Alphanumeric`

`impl UnsafeUnpin for Alphanumeric`

`impl UnwindSafe for Alphanumeric`

Blanket Implementations

`impl<T> Any for Alphanumeric where T: 'static + ?Sized,`

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for Alphanumeric where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for Alphanumeric where T: ?Sized,`

fn borrow_mut(&mut self) -> &mut T

`impl<T> CloneToUninit for Alphanumeric where T: Clone,`

unsafe fn clone_to_uninit(&self, dest: *mut u8)

`impl<T> DeserializeOwned for Alphanumeric where T: for<'de> Deserialize<'de>,`

`impl<T> From<T> for Alphanumeric`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> ToOwned for Alphanumeric where T: Clone,`

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

`impl<T, U> Into<U> for Alphanumeric where U: From<T>,`

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom<U> for Alphanumeric where U: Into<T>,`

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto<U> for Alphanumeric where U: TryFrom<T>,`

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>