pub trait ValueGenerator: Sized {
    type Output;

    // Required method
    fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>;

    // Provided methods
    fn mutate<D: Driver>(
        &self,
        driver: &mut D,
        value: &mut Self::Output
    ) -> Option<()> { ... }
    fn map<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F> { ... }
    fn map_gen<F: Fn(Self::Output) -> T, T>(
        self,
        map: F
    ) -> MapGenerator<Self, F> { ... }
    fn and_then<F: Fn(Self::Output) -> T, T: ValueGenerator>(
        self,
        and_then: F
    ) -> AndThenGenerator<Self, F> { ... }
    fn and_then_gen<F: Fn(Self::Output) -> T, T: ValueGenerator>(
        self,
        and_then: F
    ) -> AndThenGenerator<Self, F> { ... }
    fn filter<F: Fn(&Self::Output) -> bool>(
        self,
        filter: F
    ) -> FilterGenerator<Self, F> { ... }
    fn filter_gen<F: Fn(&Self::Output) -> bool>(
        self,
        filter: F
    ) -> FilterGenerator<Self, F> { ... }
    fn filter_map<F: Fn(Self::Output) -> Option<T>, T>(
        self,
        filter_map: F
    ) -> FilterMapGenerator<Self, F> { ... }
    fn filter_map_gen<F: Fn(Self::Output) -> Option<T>, T>(
        self,
        filter_map: F
    ) -> FilterMapGenerator<Self, F> { ... }
}
Expand description

Generate a value with a parameterized generator

Required Associated Types§

Required Methods§

source

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

Generates a value with the given driver

Provided Methods§

source

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

Mutates an existing value with the given driver

source

fn map<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F>

Map the value of a generator

source

fn map_gen<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F>

Map the value of a generator, exists to reduce conflicts with other map functions.

source

fn and_then<F: Fn(Self::Output) -> T, T: ValueGenerator>( self, and_then: F ) -> AndThenGenerator<Self, F>

Map the value of a generator with a new generator

source

fn and_then_gen<F: Fn(Self::Output) -> T, T: ValueGenerator>( self, and_then: F ) -> AndThenGenerator<Self, F>

Map the value of a generator with a new generator, exists to reduce conflicts with other map functions.

source

fn filter<F: Fn(&Self::Output) -> bool>( self, filter: F ) -> FilterGenerator<Self, F>

Filter the value of a generator

source

fn filter_gen<F: Fn(&Self::Output) -> bool>( self, filter: F ) -> FilterGenerator<Self, F>

Filter the value of a generator, exists to reduce conflicts with other filter functions.

source

fn filter_map<F: Fn(Self::Output) -> Option<T>, T>( self, filter_map: F ) -> FilterMapGenerator<Self, F>

Filter the value of a generator and map it to something else

source

fn filter_map_gen<F: Fn(Self::Output) -> Option<T>, T>( self, filter_map: F ) -> FilterMapGenerator<Self, F>

Filter the value of a generator and map it to something else, exists to reduce conflicts with other filter_map functions.

Implementations on Foreign Types§

source§

impl<T: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

source§

impl ValueGenerator for char

§

type Output = char

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<F: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator> ValueGenerator for (A, B, C, D, E, F)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<S: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

source§

impl<H: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<G: ValueGenerator, const LEN: usize> ValueGenerator for [G; LEN]

§

type Output = [<G as ValueGenerator>::Output; LEN]

source§

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

source§

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

source§

impl ValueGenerator for i32

§

type Output = i32

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<Y: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y)

source§

impl ValueGenerator for ()

§

type Output = ()

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl ValueGenerator for i16

§

type Output = i16

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl ValueGenerator for u64

§

type Output = u64

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<D: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator> ValueGenerator for (A, B, C, D)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl ValueGenerator for f32

§

type Output = f32

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<AA: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA)

source§

impl<X: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X)

source§

impl ValueGenerator for String

§

type Output = String

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<Z: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z)

source§

impl ValueGenerator for u16

§

type Output = u16

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<T> ValueGenerator for PhantomData<T>

§

type Output = PhantomData<T>

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self::Output>

source§

impl<M: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<R: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

source§

impl ValueGenerator for isize

§

type Output = isize

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<AB: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB)

source§

impl ValueGenerator for u128

§

type Output = u128

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<T: BoundedValue> ValueGenerator for RangeTo<T>

§

type Output = T

source§

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

source§

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

source§

impl<V: ValueGenerator, K: ValueGenerator> ValueGenerator for HashMap<K, V>where K::Output: Sized + Hash + Eq,

source§

impl<AC: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC)

source§

impl<C: ValueGenerator, A: ValueGenerator, B: ValueGenerator> ValueGenerator for (A, B, C)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<I: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl ValueGenerator for i8

§

type Output = i8

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl ValueGenerator for u32

§

type Output = u32

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<V: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

source§

impl ValueGenerator for usize

§

type Output = usize

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<A: ValueGenerator> ValueGenerator for (A,)

§

type Output = (<A as ValueGenerator>::Output,)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<N: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<L: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<K: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<O: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl ValueGenerator for u8

§

type Output = u8

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<T: BoundedValue> ValueGenerator for RangeToInclusive<T>

§

type Output = T

source§

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

source§

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

source§

impl ValueGenerator for i64

§

type Output = i64

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<AD: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator, AC: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD)

source§

impl<J: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<AE: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator, AC: ValueGenerator, AD: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE)

source§

impl<AF: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator, AC: ValueGenerator, AD: ValueGenerator, AE: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF)

source§

impl<G: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<E: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator> ValueGenerator for (A, B, C, D, E)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<T: BoundedValue> ValueGenerator for RangeInclusive<T>

§

type Output = T

source§

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

source§

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

source§

impl<AG: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator, W: ValueGenerator, X: ValueGenerator, Y: ValueGenerator, Z: ValueGenerator, AA: ValueGenerator, AB: ValueGenerator, AC: ValueGenerator, AD: ValueGenerator, AE: ValueGenerator, AF: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG)

source§

impl<T: BoundedValue> ValueGenerator for RangeFrom<T>

§

type Output = T

source§

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

source§

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

source§

impl<U: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

source§

impl<T: BoundedValue> ValueGenerator for Range<T>

§

type Output = T

source§

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

source§

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

source§

impl<B: ValueGenerator, A: ValueGenerator> ValueGenerator for (A, B)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<W: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator, S: ValueGenerator, T: ValueGenerator, U: ValueGenerator, V: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W)

source§

impl ValueGenerator for i128

§

type Output = i128

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<'a, T: ValueGenerator> ValueGenerator for &'a T

§

type Output = <T as ValueGenerator>::Output

source§

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

source§

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

source§

impl ValueGenerator for bool

§

type Output = bool

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self::Output>

source§

impl ValueGenerator for f64

§

type Output = f64

source§

fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>

source§

impl<Q: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output, <Q as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<P: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

§

type Output = (<A as ValueGenerator>::Output, <B as ValueGenerator>::Output, <C as ValueGenerator>::Output, <D as ValueGenerator>::Output, <E as ValueGenerator>::Output, <F as ValueGenerator>::Output, <G as ValueGenerator>::Output, <H as ValueGenerator>::Output, <I as ValueGenerator>::Output, <J as ValueGenerator>::Output, <K as ValueGenerator>::Output, <L as ValueGenerator>::Output, <M as ValueGenerator>::Output, <N as ValueGenerator>::Output, <O as ValueGenerator>::Output, <P as ValueGenerator>::Output)

source§

fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>

source§

fn mutate<D_: Driver>( &self, driver: &mut D_, value: &mut Self::Output ) -> Option<()>

source§

impl<V: ValueGenerator> ValueGenerator for HashSet<V>where V::Output: Sized + Hash + Eq,

§

type Output = HashSet<<V as ValueGenerator>::Output, RandomState>

source§

fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>

source§

fn mutate<D: Driver>( &self, driver: &mut D, value: &mut Self::Output ) -> Option<()>

Implementors§

source§

impl ValueGenerator for BooleanGenerator

§

type Output = bool

source§

impl<G: ValueGenerator<Output = char>, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for StringGenerator<G, L>

source§

impl<G: ValueGenerator, F: Fn(&G::Output) -> bool> ValueGenerator for FilterGenerator<G, F>

source§

impl<G: ValueGenerator, F: Fn(G::Output) -> Option<T>, T> ValueGenerator for FilterMapGenerator<G, F>

§

type Output = T

source§

impl<G: ValueGenerator, H: ValueGenerator, F: Fn(G::Output) -> H> ValueGenerator for AndThenGenerator<G, F>

source§

impl<G: ValueGenerator, M: Fn(G::Output) -> T, T> ValueGenerator for MapGenerator<G, M>

§

type Output = T

source§

impl<K: ValueGenerator, V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BTreeMapGenerator<K, V, L>where K::Output: Sized + Ord,

source§

impl<K: ValueGenerator, V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for HashMapGenerator<K, V, L>where K::Output: Sized + Hash + Eq,

source§

impl<Left: ValueGenerator, Right: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for EitherGenerator<Left, Right, Selector>

§

type Output = Either<<Left as ValueGenerator>::Output, <Right as ValueGenerator>::Output>

source§

impl<O: OneOfGenerator> ValueGenerator for OneOf<O>

source§

impl<O: OneValueOfGenerator> ValueGenerator for OneValueOf<O>

source§

impl<Ok: ValueGenerator, Err: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for ResultGenerator<Ok, Err, Selector>

source§

impl<Seconds, Nanos> ValueGenerator for DurationGenerator<Seconds, Nanos>where Seconds: ValueGenerator<Output = u64>, Nanos: ValueGenerator<Output = u32>,

source§

impl<Start, End, T> ValueGenerator for RangeGenerator<Start, End>where Start: ValueGenerator<Output = T>, End: ValueGenerator<Output = T>,

§

type Output = Range<T>

source§

impl<Start, End, T> ValueGenerator for RangeInclusiveGenerator<Start, End>where Start: ValueGenerator<Output = T>, End: ValueGenerator<Output = T>,

source§

impl<T: BoundedValue, B: RangeBounds<T>> ValueGenerator for BoundedGenerator<T, B>

§

type Output = T

source§

impl<T: Clone> ValueGenerator for Constant<T>

§

type Output = T

source§

impl<T: TypeGenerator> ValueGenerator for TypeValueGenerator<T>

§

type Output = T

source§

impl<V: ValueGenerator> ValueGenerator for BTreeSet<V>where V::Output: Sized + Ord,

source§

impl<V: ValueGenerator> ValueGenerator for BinaryHeap<V>where V::Output: Sized + Ord,

source§

impl<V: ValueGenerator> ValueGenerator for LinkedList<V>

source§

impl<V: ValueGenerator> ValueGenerator for Vec<V>

source§

impl<V: ValueGenerator> ValueGenerator for VecDeque<V>

source§

impl<V: ValueGenerator, K: ValueGenerator> ValueGenerator for BTreeMap<K, V>where K::Output: Sized + Ord,

source§

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BTreeSetGenerator<V, L>where V::Output: Sized + Ord,

source§

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BinaryHeapGenerator<V, L>where V::Output: Sized + Ord,

source§

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for LinkedListGenerator<V, L>

source§

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for VecDequeGenerator<V, L>

source§

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for VecGenerator<V, L>

source§

impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for HashSetGenerator<V, L>where V::Output: Sized + Hash + Eq,

source§

impl<V: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for OptionGenerator<V, Selector>