Struct `Alphanumeric`

struct Alphanumeric

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

Example

use rand::Rng;
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:

Implementations

`impl Clone for Alphanumeric`

fn clone(self: &Self) -> Alphanumeric

`impl Copy for Alphanumeric`

`impl Debug for Alphanumeric`

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

`impl Default for Alphanumeric`

fn default() -> Alphanumeric

`impl Distribution for Alphanumeric`

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

`impl Freeze for Alphanumeric`

`impl RefUnwindSafe for Alphanumeric`

`impl SampleString for Alphanumeric`

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

`impl Send for Alphanumeric`

`impl Serialize for Alphanumeric`

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

`impl Sync for Alphanumeric`

`impl Unpin for Alphanumeric`

`impl UnsafeUnpin for Alphanumeric`

`impl UnwindSafe for Alphanumeric`

`impl<'de> Deserialize for Alphanumeric`

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

`impl<T> Any for Alphanumeric`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Alphanumeric`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Alphanumeric`

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

`impl<T> CloneToUninit for Alphanumeric`

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

`impl<T> DeserializeOwned for Alphanumeric`

`impl<T> From for Alphanumeric`

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

`impl<T> ToOwned for Alphanumeric`

fn to_owned(self: &Self) -> T
fn clone_into(self: &Self, target: &mut T)

`impl<T, U> Into for Alphanumeric`

fn into(self: 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 for Alphanumeric`

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

`impl<T, U> TryInto for Alphanumeric`

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

`impl<V, T> VZip for Alphanumeric`

fn vzip(self: Self) -> V