Struct Gen

pub struct Gen<A> { /* private fields */ }

Generator that generates values.

Implementations

impl<A: Clone + 'static> Gen<A>

pub fn run(self, rng: RNG) -> (A, RNG)

Evaluates the Gen with a given RNG to produce a value.

Arguments

• rng - The random number generator to use

Returns

• A tuple (A, RNG) containing the generated value and the updated RNG state

Examples

use prop_check_rs::gen::Gens;
use prop_check_rs::rng::RNG;
let gen = Gens::choose(1, 10);
let (value, new_rng) = gen.run(RNG::new());
assert!(value >= 1 && value <= 10);

pub fn new<B>(b: State<RNG, B>) -> Gen<B>

Creates a new Gen by wrapping a State.

Arguments

• b - The State to wrap in a Gen

Returns

• A new Gen<B> containing the provided State

pub fn map<B, F>(self, f: F) -> Gen<B>

where F: Fn(A) -> B + 'static, B: Clone + 'static,

Transforms the output of a Gen using a function.

Arguments

• f - A function to apply to the generated value

Returns

• A new Gen<B> that applies the function to generated values

Type Parameters

• B - The result type after applying the function
• F - The function type, must be Fn(A) -> B + ’static

Examples

use prop_check_rs::gen::Gens;
let numbers = Gens::choose(1, 10);
let doubled = numbers.map(|x| x * 2);  // Generates numbers from 2 to 20

pub fn and_then<B, C, F>(self, g: Gen<B>, f: F) -> Gen<C>

where F: Fn(A, B) -> C + 'static, A: Clone, B: Clone + 'static, C: Clone + 'static,

Combines two Gens using a function that takes both of their results.

Arguments

• g - Another Gen to combine with this one
• f - A function that combines the results of both Gens

Returns

• A new Gen<C> that combines the results of both Gens

Type Parameters

• B - The type of the second Gen’s output
• C - The result type after combining both outputs
• F - The function type, must be Fn(A, B) -> C + ’static

Examples

use prop_check_rs::gen::Gens;
let x = Gens::choose(1, 5);
let y = Gens::choose(6, 10);
let sum = x.and_then(y, |a, b| a + b);  // Generates sums from 7 to 15

pub fn flat_map<B, F>(self, f: F) -> Gen<B>

where F: Fn(A) -> Gen<B> + 'static, B: Clone + 'static,

Chains this Gen with a function that returns another Gen.

Arguments

• f - A function that takes the result of this Gen and returns a new Gen

Returns

• A new Gen<B> that represents the chained computation

Type Parameters

• B - The type of the resulting Gen
• F - The function type, must be Fn(A) -> Gen + ’static

Examples

use prop_check_rs::gen::Gens;
let numbers = Gens::choose(1, 3);
let repeated = numbers.flat_map(|n| Gens::list_of_n(n, Gens::pure(n)));

Trait Implementations

impl<A: Clone + 'static> Clone for Gen<A>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A: Debug> Debug for Gen<A>

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

Formats the value using the given formatter.