nanorand

https://docs.rs/nanorand/0.8.0/nanorand/
Admin
A library meant for fast, random number generation with quick compile time, and minimal...
Tokens:59,429
Snippets:805
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Example Search Queries

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html?search=

Provides examples of search queries that can be used within the system. These demonstrate different search patterns.

```text
std::vec
```

```text
u32 -> bool
```

```text
Option<T>, (T -> U) -> Option<U>
```

--------------------------------

### Pcg64 Implementor

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/trait.SeedableRng.html?search=u32+-%3E+bool

Example of Pcg64 implementing SeedableRng. Requires the 'pcg64' crate feature.

```rust
impl SeedableRng<16, 8> for Pcg64
```

--------------------------------

### WyRand Implementor

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/trait.SeedableRng.html?search=u32+-%3E+bool

Example of WyRand implementing SeedableRng. Requires the 'wyrand' crate feature.

```rust
impl SeedableRng<8, 8> for WyRand
```

--------------------------------

### ChaCha Implementor

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/trait.SeedableRng.html?search=u32+-%3E+bool

Example of ChaCha implementing SeedableRng. Requires the 'chacha' crate feature.

```rust
impl<const ROUNDS: u8> SeedableRng<40, 64> for ChaCha<ROUNDS>
```

--------------------------------

### BufferedRng Implementor

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/trait.SeedableRng.html?search=u32+-%3E+bool

Example of BufferedRng implementing SeedableRng. Requires the 'alloc' crate feature.

```rust
impl<InternalGenerator: SeedableRng<SEED_SIZE, OUTPUT>, const OUTPUT: usize, const SEED_SIZE: usize> SeedableRng<SEED_SIZE, OUTPUT> for BufferedRng<InternalGenerator, OUTPUT>
```

--------------------------------

### Shuffle a Vec

Source: https://docs.rs/nanorand/0.8.0/nanorand/index.html?search=

This example demonstrates how to shuffle the elements of a vector in place using the shuffle method from the Rng trait and WyRand.

```rust
use nanorand::{Rng, WyRand};

let mut rng = WyRand::new();
let mut items = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
rng.shuffle(&mut items);
```

--------------------------------

### Get TypeId

Source: https://docs.rs/nanorand/0.8.0/nanorand/buffer/struct.BufferedRng.html?search=

Gets the `TypeId` of the current type. This is part of the Any trait implementation.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Get Type ID of a Type

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the TypeId of a given type. This is a blanket implementation for any type T that is 'static and sized.

```rust
fn type_id(&self) -> TypeId
where T: 'static + ?Sized
```

--------------------------------

### chacha_init

Source: https://docs.rs/nanorand/0.8.0/nanorand/crypto/chacha/index.html?search=

Initializes the ChaCha internal state using a 256-bit key and a 64-bit nonce.

```APIDOC
## chacha_init

### Description
Initializes the ChaCha internal state with a 256-bit key and a 64-bit nonce.

### Parameters
* **key** (256-bit): The secret key for ChaCha.
* **nonce** (64-bit): The nonce to be used with the key.

### Return Value
This function does not explicitly list a return value in the source. Refer to the implementation for details.
```

--------------------------------

### chacha_init

Source: https://docs.rs/nanorand/0.8.0/nanorand/crypto/chacha/fn.chacha_init.html?search=std%3A%3Avec

Initializes the ChaCha internal state with a 256-bit key and a 64-bit nonce. It takes a key, counter, and nonce as input and returns the initialized 128-bit ChaCha state.

```APIDOC
## chacha_init

nanorand::crypto::chacha

### Description
Initialize the ChaCha internal state, with a 256-bit key and 64-bit nonce.

### Signature
```rust
pub const fn chacha_init(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> [u32; 16]
```

### Parameters
* **key** (`[u8; 32]`) - A 256-bit key.
* **counter** (`[u8; 8]`) - A 64-bit counter.
* **nonce** (`[u8; 8]`) - A 64-bit nonce.

### Returns
* `[u32; 16]` - The initialized 128-bit ChaCha state.
```

--------------------------------

### Pcg64::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=std%3A%3Avec

Creates a new Pcg64 instance, seeding from the system's default source of entropy. This requires the `entropy` or `getrandom` crate feature.

```APIDOC
## Pcg64::new()

### Description
Creates a new `Pcg64` instance, seeding from the system’s default source of entropy.

### Method
`pub fn new() -> Self`

### Available on
`crate features`entropy` or `getrandom`
```

--------------------------------

### Pcg64::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Creates a new Pcg64 instance, seeding from the system's default source of entropy. This requires the 'entropy' or 'getrandom' crate feature.

```APIDOC
## Pcg64::new

### Description
Creates a new `Pcg64` instance, seeding from the system’s default source of entropy.

### Method
`pub fn new() -> Self`

### Available On
`crate feature "entropy"` or `crate feature "getrandom"`
```

--------------------------------

### Pcg64::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new Pcg64 instance, seeding from the system's default source of entropy. This is available when the `entropy` or `getrandom` crate features are enabled.

```APIDOC
## Pcg64::new

### Description
Creates a new `Pcg64` instance, seeding from the system’s default source of entropy.

### Method
`pub fn new() -> Self`

### Availability
Available on **crate features`entropy` or `getrandom`** only.
```

--------------------------------

### Pcg64::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=

Creates a new Pcg64 instance seeded from the system's default entropy source. This is available when the `entropy` or `getrandom` crate features are enabled.

```APIDOC
## Pcg64::new

### Description
Create a new `Pcg64` instance, seeding from the system’s default source of entropy.

### Method
`pub fn new() -> Self`

### Available On
`crate feature`entropy` or `getrandom`
```

--------------------------------

### chacha_init

Source: https://docs.rs/nanorand/0.8.0/nanorand/crypto/chacha/fn.chacha_init.html?search=

Initializes the ChaCha internal state with a 256-bit key and a 64-bit nonce. The function takes the key, counter, and nonce as byte arrays and returns the initialized state as an array of 16 u32 values.

```APIDOC
## chacha_init

nanorand::crypto::chacha

### Description
Initialize the ChaCha internal state, with a 256-bit key and 64-bit nonce.

### Signature
```rust
pub const fn chacha_init(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> [u32; 16]
```

### Parameters
* **key** ([u8; 32]) - The 256-bit key for ChaCha.
* **counter** ([u8; 8]) - The 64-bit counter for ChaCha.
* **nonce** ([u8; 8]) - The 64-bit nonce for ChaCha.

### Returns
* `[u32; 16]` - The initialized ChaCha internal state.
```

--------------------------------

### chacha_init

Source: https://docs.rs/nanorand/0.8.0/nanorand/crypto/chacha/fn.chacha_init.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes the ChaCha internal state using a 256-bit key, a 64-bit counter, and a 64-bit nonce. Returns the initialized 128-bit state.

```APIDOC
## Function: chacha_init

### Description
Initialize the ChaCha internal state, with a 256-bit key and 64-bit nonce.

### Signature
```rust
pub const fn chacha_init(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> [u32; 16]
```

### Parameters
* **key** (`[u8; 32]`) - A 256-bit key.
* **counter** (`[u8; 8]`) - A 64-bit counter.
* **nonce** (`[u8; 8]`) - A 64-bit nonce.

### Returns
* `[u32; 16]` - The initialized 128-bit ChaCha internal state.
```

--------------------------------

### Pcg64::default

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=std%3A%3Avec

Creates a new Pcg64 instance, seeding from the system's default source of entropy. This requires the `entropy` or `getrandom` crate feature.

```APIDOC
## Pcg64::default()

### Description
Create a new `Pcg64` instance, seeding from the system’s default source of entropy.

### Method
`fn default() -> Self`

### Available on
`crate features`entropy` or `getrandom`
```

--------------------------------

### chacha_init

Source: https://docs.rs/nanorand/0.8.0/nanorand/crypto/chacha/fn.chacha_init.html?search=u32+-%3E+bool

Initializes the ChaCha internal state with a 256-bit key and a 64-bit nonce. This function is part of the nanorand::crypto::chacha module.

```APIDOC
## Function chacha_init

nanorand::crypto::chacha

### Description
Initialize the ChaCha internal state, with a 256-bit key and 64-bit nonce.

### Signature
```rust
pub const fn chacha_init(
    key: [u8; 32],
    counter: [u8; 8],
    nonce: [u8; 8],
) -> [u32; 16]
```

### Parameters
* **key** (`[u8; 32]`) - A 256-bit key.
* **counter** (`[u8; 8]`) - An 8-byte counter.
* **nonce** (`[u8; 8]`) - An 8-byte nonce.

### Returns
* `[u32; 16]` - The initialized 128-bit ChaCha internal state.
```

--------------------------------

### const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html?search=std%3A%3Avec

Create a new `ChaCha` instance, using the provided key and nonce.

```APIDOC
## const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self

### Description
Create a new `ChaCha` instance, using the provided key and nonce.

```rust
pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self
```
```

--------------------------------

### Pcg64::default

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Creates a new Pcg64 instance, seeding from the system's default source of entropy. This is the default implementation and requires the 'entropy' or 'getrandom' crate feature.

```APIDOC
## Pcg64::default

### Description
Create a new `Pcg64` instance, seeding from the system’s default source of entropy.

### Method
`fn default() -> Self`

### Available On
`crate feature "entropy"` or `crate feature "getrandom"`
```

--------------------------------

### fn new() -> Self

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html?search=std%3A%3Avec

Create a new `ChaCha` instance, seeding from the system’s default source of entropy.

```APIDOC
## fn new() -> Self

### Description
Create a new `ChaCha` instance, seeding from the system’s default source of entropy.

Available on **crate features`entropy` or `getrandom`** only.

```rust
pub fn new() -> Self
```
```

--------------------------------

### ChaCha20::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha20.html

Creates a new ChaCha20 instance, seeding from the system’s default source of entropy. This method requires the 'entropy' or 'getrandom' crate feature to be enabled.

```APIDOC
## ChaCha20::new

### Description
Creates a new `ChaCha` instance, seeding from the system’s default source of entropy.

### Available On
`crate feature` `entropy` or `getrandom`

### Signature
`pub fn new() -> Self`
```

--------------------------------

### system

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.system.html?search=std%3A%3Avec

Pulls system entropy using the `getrandom` crate. It uses backup entropy (rdseed and system time) if `getrandom` fails. This function is available when the `entropy` or `getrandom` crate features are enabled.

```APIDOC
## system

### Description
Pulls system entropy using the `getrandom` crate. Uses backup entropy (rdseed and system time) if it fails.

### Function Signature
```rust
pub fn system(out: &mut [u8])
```

### Parameters
* `out` (&mut [u8]) - A mutable byte slice to fill with entropy.

### Availability
Available on (crate features`entropy` or `getrandom`) and crate feature `getrandom` only.
```

--------------------------------

### ChaCha Initialization Function Signature

Source: https://docs.rs/nanorand/0.8.0/nanorand/crypto/chacha/fn.chacha_init.html?search=std%3A%3Avec

Provides the function signature for `chacha_init`, detailing its parameters (key, counter, nonce) and return type.

```rust
pub const fn chacha_init(
    key: [u8; 32],
    counter: [u8; 8],
    nonce: [u8; 8],
) -> [u32; 16]
```

--------------------------------

### WyRand::default

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html?search=std%3A%3Avec

Creates a new WyRand instance, seeding from the system's default source of entropy. This is an alias for `WyRand::new` and requires the 'entropy' or 'getrandom' crate feature.

```APIDOC
## WyRand::default

### Description
Create a new `WyRand` instance, seeding from the system’s default source of entropy.

### Available on
`crate features` `entropy` or `getrandom` only.

### Method
`fn default() -> Self`
```

--------------------------------

### WyRand::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html?search=std%3A%3Avec

Creates a new WyRand instance, seeding it from the system's default source of entropy. This method requires the 'entropy' or 'getrandom' crate feature to be enabled.

```APIDOC
## WyRand::new

### Description
Creates a new `WyRand` instance, seeding from the system’s default source of entropy.

### Available on
`crate features` `entropy` or `getrandom` only.

### Method
`pub fn new() -> Self`
```

--------------------------------

### ChaCha20::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha20.html?search=

Creates a new ChaCha20 instance, seeding from the system’s default source of entropy. This method is available when the `entropy` or `getrandom` crate features are enabled.

```APIDOC
## ChaCha20::new

### Description
Creates a new `ChaCha` instance, seeding from the system’s default source of entropy.

### Method
`pub fn new() -> Self`

### Availability
Available on **crate features`entropy` or `getrandom`** only.

### Parameters
None

### Returns
A new `ChaCha` instance.
```

--------------------------------

### Pcg64::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=u32+-%3E+bool

Creates a new Pcg64 instance, seeding from the system's default source of entropy. This generator is NOT cryptographically secure.

```APIDOC
## Pcg64::new

### Description
Creates a new `Pcg64` instance, seeding from the system’s default source of entropy. This generator is _NOT_ cryptographically secure.

### Method
`pub fn new() -> Self`

### Available On
`crate features`"entropy" or `getrandom`
```

--------------------------------

### Create New Pcg64 Instance (Seeded)

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Creates a new Pcg64 instance using a provided 128-bit seed.

```rust
pub const fn new_seed(seed: u128) -> Self
```

--------------------------------

### Pcg64::default

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=

Provides a default Pcg64 instance, seeded from the system's entropy source. This is available when the `entropy` or `getrandom` crate features are enabled.

```APIDOC
## Pcg64::default

### Description
Create a new `Pcg64` instance, seeding from the system’s default source of entropy.

### Method
`fn default() -> Self`

### Available On
`crate features`entropy` or `getrandom`
```

--------------------------------

### system

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.system.html

Pulls system entropy using the `getrandom` crate. It falls back to using rdseed and system time if `getrandom` fails. This function is available when the `entropy` or `getrandom` feature flags are enabled.

```APIDOC
## system

### Description

Pulls system entropy using the `getrandom` crate. Uses backup entropy (rdseed and system time) if it fails.

### Function Signature

```rust
pub fn system(out: &mut [u8])
```

### Parameters

- **out** (`&mut [u8]`) - A mutable byte slice to fill with entropy.

### Availability

Available on `(crate features`entropy` or `getrandom`) and crate feature `getrandom`) only.
```

--------------------------------

### Create New ChaCha Instance with Custom Key and Nonce

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Creates a new ChaCha instance using a provided 32-byte key, 8-byte counter, and 8-byte nonce.

```rust
pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self
```

--------------------------------

### chacha_init Function

Source: https://docs.rs/nanorand/0.8.0/nanorand/crypto/chacha/fn.chacha_init.html

Initializes the ChaCha internal state using a 256-bit key, a 64-bit counter, and a 64-bit nonce. This function is part of the nanorand crypto library.

```APIDOC
## chacha_init

nanorand::crypto::chacha

### Description
Initializes the ChaCha internal state, with a 256-bit key and 64-bit nonce.

### Function Signature
```rust
pub const fn chacha_init(
    key: [u8; 32],
    counter: [u8; 8],
    nonce: [u8; 8],
) -> [u32; 16]
```

### Parameters
* **key** (`[u8; 32]`) - A 256-bit key.
* **counter** (`[u8; 8]`) - A 64-bit counter.
* **nonce** (`[u8; 8]`) - A 64-bit nonce.

### Returns
* `[u32; 16]` - The initialized ChaCha internal state.
```

--------------------------------

### Create WyRand with System Entropy

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html?search=std%3A%3Avec

Creates a new WyRand instance seeded from the system's entropy source. This requires the 'entropy' or 'getrandom' crate features. This is also the default behavior.

```rust
pub fn new() -> Self
```

```rust
fn default() -> Self
```

--------------------------------

### Pcg64::new_seed

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=u32+-%3E+bool

Creates a new Pcg64 instance using a provided seed.

```APIDOC
## Pcg64::new_seed

### Description
Creates a new `Pcg64` instance, using a provided seed.

### Method
`pub const fn new_seed(seed: u128) -> Self`
```

--------------------------------

### backup

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.backup.html?search=std%3A%3Avec

Provides a backup entropy source. It attempts to use `rdseed` first. If `rdseed` fails or is incomplete, it falls back to using system time-based entropy generation. This function is available when the `entropy` or `getrandom` features are enabled, along with the `std` feature.

```APIDOC
## Function backup

### Description
A backup entropy source, trying `rdseed` first, and if it fails or does not complete, combining it with or using system time-based entropy generation.

### Signature
`pub fn backup(out: &mut [u8])`

### Parameters
* `out` - A mutable slice of bytes where the entropy will be written.

### Availability
Available on `(crate features`entropy` or `getrandom`) and crate feature `std`** only.

### Panics
This function panics if sufficient entropy could not be obtained.
```

--------------------------------

### TryInto Pcg64

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=

Attempts to convert a Pcg64 instance into another type that implements `TryFrom<Pcg64>`.

```rust
type Error = <U as TryFrom<T>>::Error
```

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

--------------------------------

### ChaCha::new

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html

Creates a new ChaCha instance, seeding from the system's default source of entropy. This method is available when the `entropy` or `getrandom` crate features are enabled.

```APIDOC
## ChaCha::new

### Description
Creates a new `ChaCha` instance, seeding from the system’s default source of entropy.

### Available On
`crate feature` `entropy` or `getrandom` only.

### Signature
```rust
pub fn new() -> Self
```
```

--------------------------------

### Clone From Pcg64 Instance

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Performs copy-assignment from a source Pcg64 instance to the current one.

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

--------------------------------

### Pcg64::default

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=u32+-%3E+bool

Creates a new Pcg64 instance, seeding from the system's default source of entropy. This generator is NOT cryptographically secure.

```APIDOC
## Pcg64::default

### Description
Create a new `Pcg64` instance, seeding from the system’s default source of entropy. This generator is _NOT_ cryptographically secure.

### Method
`fn default() -> Self`

### Available On
`crate features`"entropy" or `getrandom`
```

--------------------------------

### Pcg64::new_seed

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=

Creates a new Pcg64 instance using a provided 128-bit seed.

```APIDOC
## Pcg64::new_seed

### Description
Create a new `Pcg64` instance, using a provided seed.

### Method
`pub const fn new_seed(seed: u128) -> Self`
```

--------------------------------

### Pcg64::new_seed

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Creates a new Pcg64 instance using a provided 128-bit seed.

```APIDOC
## Pcg64::new_seed

### Description
Creates a new `Pcg64` instance, using a provided seed.

### Method
`pub const fn new_seed(seed: u128) -> Self`

### Parameters
#### Path Parameters
- **seed** (u128) - Required - The seed value for the generator.
```

--------------------------------

### Pcg64::new_seed

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=std%3A%3Avec

Creates a new Pcg64 instance using a provided 128-bit seed.

```APIDOC
## Pcg64::new_seed()

### Description
Creates a new `Pcg64` instance, using a provided seed.

### Method
`pub const fn new_seed(seed: u128) -> Self`
```

--------------------------------

### ChaCha::new_key() Implementation

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha12.html?search=u32+-%3E+bool

Creates a new ChaCha instance using a provided key, counter, and nonce.

```rust
pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self

```

--------------------------------

### ChaCha20::new_key

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha20.html?search=

Creates a new ChaCha20 instance using a provided key, counter, and nonce.

```APIDOC
## ChaCha20::new_key

### Description
Creates a new `ChaCha` instance, using the provided key and nonce.

### Method
`pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self`

### Parameters
* **key** ([u8; 32]) - The 32-byte secret key.
* **counter** ([u8; 8]) - The 8-byte counter.
* **nonce** ([u8; 8]) - The 8-byte nonce.

### Returns
A new `ChaCha` instance.
```

--------------------------------

### ChaCha20::new_key

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha20.html

Creates a new ChaCha20 instance using a provided key, counter, and nonce. This function allows for deterministic initialization of the CSPRNG.

```APIDOC
## ChaCha20::new_key

### Description
Creates a new `ChaCha` instance, using the provided key and nonce.

### Signature
`pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self`
```

--------------------------------

### Clone Pcg64 Instance

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Returns a duplicate of the Pcg64 instance.

```rust
fn clone(&self) -> Self
```

--------------------------------

### TryInto Conversion

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Attempts to convert a Pcg64 instance into another type. Requires the target type to implement TryFrom<Pcg64>.

```rust
type Error = Infallible
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
where U: TryFrom<T>
```

--------------------------------

### backup

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.backup.html

Provides a backup entropy source by attempting to use rdseed and falling back to system time-based entropy generation if necessary. This function is available when the `entropy` or `getrandom` features are enabled, along with the `std` feature.

```APIDOC
## backup

nanorand::entropy

### Description
A backup entropy source, trying rdseed first, and if it fails or does not complete, combining it with or using system time-based entropy generation.

### Function Signature
```rust
pub fn backup(out: &mut [u8])
```

### Parameters
* `out` (&mut [u8]): A mutable byte slice to fill with entropy.

### Availability
Available on `(crate features`entropy` or `getrandom`) and crate feature `std`** only.

### Panics
This function panics if sufficient entropy could not be obtained.
```

--------------------------------

### Using BufferedRng to Fill a Byte Array

Source: https://docs.rs/nanorand/0.8.0/nanorand/buffer/struct.BufferedRng.html?search=

Demonstrates how to use BufferedRng to fill a byte array. It shows that unused bytes from the underlying generator are buffered for future use. This snippet requires the 'alloc' feature.

```rust
use nanorand::{Rng, BufferedRng, WyRand};

let mut thingy = [0u8; 5];
let mut rng = BufferedRng::new(WyRand::new());
rng.fill(&mut thingy);
// As WyRand generates 8 bytes of output, and our target is only 5 bytes,
// 3 bytes will remain in the buffer.
assert_eq!(rng.buffered(), 3);
```

--------------------------------

### WyRand::default

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html?search=

Creates a new WyRand instance, seeding from the system’s default source of entropy. This is the default implementation and requires the 'entropy' or 'getrandom' crate feature.

```APIDOC
## WyRand::default

### Description
Create a new `WyRand` instance, seeding from the system’s default source of entropy.

### Available on
`crate features`entropy` or `getrandom` only.

### Signature
```rust
fn default() -> Self
```
```

--------------------------------

### ChaCha::new_key()

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html?search=u32+-%3E+bool

Creates a new ChaCha instance using a provided key, counter, and nonce.

```APIDOC
### pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self

Create a new `ChaCha` instance, using the provided key and nonce.
```

--------------------------------

### ChaCha::new()

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html?search=u32+-%3E+bool

Creates a new ChaCha instance seeded from the system's default source of entropy.

```APIDOC
### pub fn new() -> Self

Create a new `ChaCha` instance, seeding from the system’s default source of entropy.

Available on **crate features`entropy` or `getrandom`** only.
```

--------------------------------

### nanorand::entropy::backup

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.backup.html?search=

The `backup` function serves as a fallback entropy source. It prioritizes using `rdseed` and, if that fails or is incomplete, it combines entropy with system time-based generation. This function is available when the `entropy` or `getrandom` features are enabled, along with the `std` feature.

```APIDOC
## Function backup
nanorand::entropy

### Description
A backup entropy source, trying rdseed first, and if it fails or does not complete, combining it with or using system time-based entropy generation.

### Signature
```rust
pub fn backup(out: &mut [u8])
```

### Parameters
* `out` - A mutable slice of bytes to fill with entropy.

### Availability
Available on (crate features`entropy` or `getrandom`) and crate feature `std` only.

### Panics
This function panics if sufficient entropy could not be obtained.
```

--------------------------------

### Try Convert From Pcg64

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=u32+-%3E+bool

Attempts to convert a value into a Pcg64 instance. Part of the TryFrom<U> for T trait implementation.

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

--------------------------------

### system Function Signature

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.system.html?search=u32+-%3E+bool

This function signature shows how to call the system function to retrieve system entropy. It takes a mutable byte slice as an output buffer.

```APIDOC
## system

### Description

Pull in system entropy using the `getrandom` crate. Uses backup entropy (rdseed and system time) if it fails.

### Function Signature

```rust
pub fn system(out: &mut [u8])
```

### Parameters

* `out` - A mutable slice of bytes (`&mut [u8]`) where the system entropy will be written.

### Availability

Available on (crate features`entropy` or `getrandom`) and crate feature `getrandom` only.
```

--------------------------------

### Clone to Uninitialized Memory (Nightly)

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Performs copy-assignment from self to a raw pointer in uninitialized memory. This is a nightly-only experimental API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
where T: Clone
```

--------------------------------

### ChaCha::new_key()

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha12.html?search=

Creates a new ChaCha instance using the provided key, counter, and nonce.

```APIDOC
### `fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self`

Create a new `ChaCha` instance, using the provided key and nonce.
```

--------------------------------

### ChaCha<ROUNDS> Implementations

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha12.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Provides methods for creating and seeding ChaCha instances.

```APIDOC
### impl<const ROUNDS: u8> ChaCha<ROUNDS>

#### `new()`

* **Description:** Creates a new `ChaCha` instance, seeding from the system’s default source of entropy.
* **Available on:** `crate features 'entropy' or 'getrandom'` only.

#### `new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self`

* **Description:** Creates a new `ChaCha` instance, using the provided key and nonce.
```

--------------------------------

### RandomGen Implementation for f64

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html

Implementation of RandomGen for the f64 floating-point type. It allows generating random f64 values using an RNG.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for f64 {
    // Required method
    fn random(rng: &mut Generator) -> Self;
}
```

--------------------------------

### RandomGen Implementation for f64

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html?search=std%3A%3Avec

Implementation of RandomGen for the 64-bit floating-point type.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for f64
```

--------------------------------

### Filling an Array with Randomly Generated Types using BufferedRng

Source: https://docs.rs/nanorand/0.8.0/nanorand/buffer/struct.BufferedRng.html?search=

Shows how to fill an array with instances of a specific type, where each instance is generated randomly using the `fill` method, available through the Rng trait implementation for BufferedRng.

```rust
fn fill<Contents, Array>(&mut self, target: Array)
where Contents: RandomGen<Self, OUTPUT>, Array: AsMut<[Contents]>
```

--------------------------------

### Create From Value

Source: https://docs.rs/nanorand/0.8.0/nanorand/buffer/struct.BufferedRng.html?search=

Creates a new instance from a value of the same type. This is part of the From trait implementation.

```rust
fn from(t: T) -> T
```

--------------------------------

### Filling a Byte Slice with Randomness using BufferedRng

Source: https://docs.rs/nanorand/0.8.0/nanorand/buffer/struct.BufferedRng.html?search=

Demonstrates how to fill a mutable slice of bytes with random data using the `fill_bytes` method provided by the Rng trait implementation for BufferedRng.

```rust
fn fill_bytes<Bytes>(&mut self, output: Bytes)
where Bytes: AsMut<[u8]>
```

--------------------------------

### Format Pcg64 Instance for Debug

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Formats the Pcg64 instance for debugging purposes using the given formatter.

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

--------------------------------

### RandomGen Implementation for usize

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html?search=std%3A%3Avec

Implementation of RandomGen for the unsigned integer type corresponding to the platform's pointer size.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for usize
```

--------------------------------

### Pcg64::rand

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=std%3A%3Avec

Generates a random sequence of 8 bytes, seeding from the internal state.

```APIDOC
## Pcg64::rand()

### Description
Generates a random sequence of bytes, seeding from the internal state.

### Method
`fn rand(&mut self) -> [u8; 8]`
```

--------------------------------

### RandomGen Implementation for i64

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html?search=std%3A%3Avec

Implementation of RandomGen for the 64-bit signed integer type.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for i64
```

--------------------------------

### WyRand::new_seed

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html?search=std%3A%3Avec

Creates a new WyRand instance using a provided 64-bit unsigned integer seed.

```APIDOC
## WyRand::new_seed

### Description
Creates a new `WyRand` instance, using a provided seed.

### Method
`pub const fn new_seed(seed: u64) -> Self`
```

--------------------------------

### try_into Method

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html

Provides the functionality to attempt a conversion of the current type into another type `U`. It returns a `Result` which is either the successfully converted value or an error if the conversion fails.

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

### Description
Performs the conversion from the current type to a target type `U` that implements `TryFrom`. This method is essential for safe type conversions where failure is possible.

### Method
`try_into`

### Parameters
- `self`: The instance of the type to be converted.

### Returns
- `Result<U, <U as TryFrom<T>>::Error>`: Ok(U) if the conversion is successful, Err(E) if the conversion fails, where E is the error type defined by `TryFrom`.
```

--------------------------------

### RandomGen Implementation for u64

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html

Implementation of RandomGen for the u64 integer type. It allows generating random u64 values using an RNG.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for u64 {
    // Required method
    fn random(rng: &mut Generator) -> Self;
}
```

--------------------------------

### RandomGen Implementation for usize

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html

Implementation of RandomGen for the usize integer type. It allows generating random usize values using an RNG.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for usize {
    // Required method
    fn random(rng: &mut Generator) -> Self;
}
```

--------------------------------

### Create WyRand with a Specific Seed

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/wyrand/struct.WyRand.html?search=std%3A%3Avec

Creates a new WyRand instance using a provided 64-bit seed value.

```rust
pub const fn new_seed(seed: u64) -> Self
```

--------------------------------

### RandomGen Implementation for i64

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html

Implementation of RandomGen for the i64 integer type. It allows generating random i64 values using an RNG.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for i64 {
    // Required method
    fn random(rng: &mut Generator) -> Self;
}
```

--------------------------------

### ChaCha::new_key

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html?search=

Creates a new ChaCha instance using a provided 32-byte key, 8-byte counter, and 8-byte nonce.

```APIDOC
## ChaCha::new_key

### Description

Create a new `ChaCha` instance, using the provided key and nonce.

### Method

`pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self`

### Parameters

* **key** (`[u8; 32]`) - The 32-byte secret key.
* **counter** (`[u8; 8]`) - The 8-byte counter.
* **nonce** (`[u8; 8]`) - The 8-byte nonce.

### Usage

```rust
use nanorand::rand::chacha::ChaCha;

let key = [0u8; 32];
let counter = [0u8; 8];
let nonce = [0u8; 8];
let mut rng = ChaCha::<12>::new_key(key, counter, nonce); // Using 12 rounds as an example
let random_bytes: [u8; 64] = rng.rand();
```
```

--------------------------------

### ChaCha::new()

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha12.html?search=

Creates a new ChaCha instance, seeding from the system's default source of entropy. Available when 'entropy' or 'getrandom' features are enabled.

```APIDOC
### `fn new() -> Self`

Available on **crate features`entropy` or `getrandom`** only.

Create a new `ChaCha` instance, seeding from the system’s default source of entropy.
```

--------------------------------

### ChaCha::new_key

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/struct.ChaCha.html

Creates a new ChaCha instance using a provided key, counter, and nonce.

```APIDOC
## ChaCha::new_key

### Description
Creates a new `ChaCha` instance, using the provided key and nonce.

### Signature
```rust
pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self
```
```

--------------------------------

### ChaCha<ROUNDS> Implementations

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha8.html

Provides details on the implementations for the generic ChaCha struct, which ChaCha8 is an alias for. This includes methods for creation, seeding, and random number generation.

```APIDOC
### impl<const ROUNDS: u8> ChaCha<ROUNDS>

#### `pub fn new() -> Self`

**Availability**: Available on `crate features 'entropy' or 'getrandom'` only.

**Description**: Create a new `ChaCha` instance, seeding from the system’s default source of entropy.
```

```APIDOC
#### `pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self`

**Description**: Create a new `ChaCha` instance, using the provided key and nonce.
```

--------------------------------

### RandomGen Implementation for u64

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html?search=std%3A%3Avec

Implementation of RandomGen for the 64-bit unsigned integer type.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for u64
```

--------------------------------

### system function signature

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.system.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

The `system` function takes a mutable byte slice as an argument to fill with entropy. It is available when the `entropy` or `getrandom` crate features are enabled. It uses the `getrandom` crate for entropy and falls back to rdseed and system time if `getrandom` fails.

```rust
pub fn system(out: &mut [u8])
```

--------------------------------

### ChaCha<ROUNDS> Implementations

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha12.html

Provides details on the implementations for the generic ChaCha struct, which ChaCha12 is an alias for. This includes methods for creating new instances, seeding, and generating random data.

```APIDOC
## Implementations for ChaCha<ROUNDS>

### `impl<const ROUNDS: u8> ChaCha<ROUNDS>`

#### `pub fn new() -> Self`

**Feature:** Available on `crate features` `entropy` or `getrandom` only.

**Description:** Create a new `ChaCha` instance, seeding from the system’s default source of entropy.
```

```APIDOC
#### `pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self`

**Description:** Create a new `ChaCha` instance, using the provided key and nonce.
```

--------------------------------

### ChaCha Default Implementation

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha12.html

Provides a default ChaCha instance, seeded from the system's entropy source. Available on 'entropy' or 'getrandom' crate features.

```rust
fn default() -> Self

```

--------------------------------

### RandomGen Implementation for i32

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html

Implementation of RandomGen for the i32 integer type. It allows generating random i32 values using an RNG.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for i32 {
    // Required method
    fn random(rng: &mut Generator) -> Self;
}
```

--------------------------------

### ChaCha<ROUNDS> Implementations

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/chacha/type.ChaCha20.html?search=u32+-%3E+bool

Provides methods for creating and seeding ChaCha instances, and for generating random data. Feature flags may affect availability.

```APIDOC
## Implementations for `ChaCha<ROUNDS>`

### `new()`

**Description:** Creates a new `ChaCha` instance, seeding from the system’s default source of entropy.

**Availability:** Crate features `entropy` or `getrandom` only.

**Signature:** `pub fn new() -> Self`

### `new_key()`

**Description:** Creates a new `ChaCha` instance, using the provided key and nonce.

**Signature:** `pub const fn new_key(key: [u8; 32], counter: [u8; 8], nonce: [u8; 8]) -> Self`

### `rand()`

**Description:** Generates a random sequence of bytes, seeding from the internal state.

**Signature:** `fn rand(&mut self) -> [u8; 64]`

### `generate()`

**Description:** Generates a random of the specified type, seeding from the internal state.

**Signature:** `fn generate<Generated>(&mut self) -> Generated where Generated: RandomGen<Self, OUTPUT>`

### `fill_bytes()`

**Description:** Fill an array of bytes with randomness.

**Signature:** `fn fill_bytes<Bytes>(&mut self, buffer: Bytes) where Bytes: AsMut<[u8]>`

### `fill()`

**Description:** Fill an array with the specified type.

**Signature:** `fn fill<Contents, Array>(&mut self, target: Array) where Contents: RandomGen<Self, OUTPUT>, Array: AsMut<[Contents]>`

### `generate_range()`

**Description:** Generates a random of the specified type, seeding from the internal state.

**Signature:** `fn generate_range<Number, Bounds>(&mut self, range: Bounds) -> Number where Number: RandomRange<Self, OUTPUT>, Bounds: RangeBounds<Number>`

### `shuffle()`

**Description:** Shuffle a slice, using the RNG.

**Signature:** `fn shuffle<Contents, Array>(&mut self, target: Array) where Array: AsMut<[Contents]>`

### `reseed()`

**Description:** Re-seed the RNG with the specified bytes.

**Signature:** `fn reseed(&mut self, seed: [u8; 40])`

### `zeroize()`

**Description:** Zero out this object from memory using Rust intrinsics which ensure the zeroization operation is not “optimized away” by the compiler.

**Signature:** `fn zeroize(&mut self)`

### `default()`

**Description:** Returns the “default value” for a type.

**Availability:** Crate features `entropy` or `getrandom` only.
```

--------------------------------

### To Owned Pcg64

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html?search=

Creates owned data from a borrowed Pcg64 instance, usually by cloning.

```rust
type Owned = T
```

```rust
fn to_owned(&self) -> T
```

```rust
fn clone_into(&self, target: &mut T)
```

--------------------------------

### RandomGen Implementation for f32

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html

Implementation of RandomGen for the f32 floating-point type. It allows generating random f32 values using an RNG.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for f32 {
    // Required method
    fn random(rng: &mut Generator) -> Self;
}
```

--------------------------------

### Rng<8> for Pcg64

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/pcg64/struct.Pcg64.html

Implementations for generating random bytes and sequences using the Pcg64 generator.

```APIDOC
## Rng<8> for Pcg64

### Description
Provides methods for generating random data using the Pcg64 generator.

### Methods
- **`rand(&mut self) -> [u8; 8]`**: Generates a random sequence of 8 bytes.
- **`fill_bytes(&mut self, buffer: Bytes)`**: Fills a mutable byte slice with random data.
- **`generate<Generated>(&mut self) -> Generated`**: Generates a random value of a specified type.
- **`fill<Contents, Array>(&mut self, target: Array)`**: Fills an array with random values of a specified type.
- **`generate_range<Number, Bounds>(&mut self, range: Bounds) -> Number`**: Generates a random number within a specified range.
- **`shuffle<Contents, Array>(&mut self, target: Array)`**: Shuffles a slice in place using the RNG.
```

--------------------------------

### backup function signature

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.backup.html

This is the function signature for the backup entropy source. It requires a mutable byte slice to fill with entropy. Available on (crate features`entropy` or `getrandom`) and crate feature `std` only.

```rust
pub fn backup(out: &mut [u8])
```

--------------------------------

### RandomGen Implementation for i16

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html

Implementation of RandomGen for the i16 integer type. It allows generating random i16 values using an RNG.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for i16 {
    // Required method
    fn random(rng: &mut Generator) -> Self;
}
```

--------------------------------

### nanorand::entropy::system

Source: https://docs.rs/nanorand/0.8.0/nanorand/entropy/fn.system.html?search=

Pulls system entropy using the `getrandom` crate. It falls back to using rdseed and system time if the primary method fails. This function is available when the `entropy` or `getrandom` feature flags are enabled.

```APIDOC
## Function system

### Description

Pulls system entropy using the `getrandom` crate. Uses backup entropy (rdseed and system time) if it fails.

### Signature

```rust
pub fn system(out: &mut [u8])
```

### Parameters

* **out** (`&mut [u8]`) - A mutable byte slice to fill with entropy.

### Availability

Available on `(crate features`entropy` or `getrandom`) and crate feature `getrandom` only.
```

--------------------------------

### Re-export WyRand PRNG

Source: https://docs.rs/nanorand/0.8.0/nanorand/rand/index.html?search=

Re-exports the WyRand PRNG algorithm from the 'wyrand' crate. Known for its speed and simplicity.

```rust
pub use wyrand::WyRand;

```

--------------------------------

### RandomGen Implementation for i32

Source: https://docs.rs/nanorand/0.8.0/nanorand/gen/trait.RandomGen.html?search=std%3A%3Avec

Implementation of RandomGen for the 32-bit signed integer type.

```rust
impl<Generator: Rng<OUTPUT>, const OUTPUT: usize> RandomGen<Generator, OUTPUT> for i32
```

--------------------------------

### Clone to Uninitialized Memory

Source: https://docs.rs/nanorand/0.8.0/nanorand/buffer/struct.BufferedRng.html?search=

Performs copy-assignment from self to a raw pointer. This is a nightly-only experimental API.

```rust
unsafe fn clone_to_uninit(&self, dest: *mut u8)
```
Tokens:
Raw