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_gen<F: Fn(Self::Output) -> T, T>(
        self,
        map: F
    ) -> MapGenerator<Self, F> { ... }
    fn and_then_gen<F: Fn(Self::Output) -> T, T: ValueGenerator>(
        self,
        and_then: F
    ) -> AndThenGenerator<Self, F> { ... }
    fn filter_gen<F: Fn(&Self::Output) -> bool>(
        self,
        filter: F
    ) -> FilterGenerator<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_gen<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F>

Map the value of a 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

source

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

Filter the value of a generator

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

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl ValueGenerator for bool

§

type Output = bool

source§

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

source§

impl ValueGenerator for char

§

type Output = char

source§

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

source§

impl ValueGenerator for f32

§

type Output = f32

source§

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

source§

impl ValueGenerator for f64

§

type Output = f64

source§

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

source§

impl ValueGenerator for i8

§

type Output = i8

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 i32

§

type Output = i32

source§

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

source§

impl ValueGenerator for i64

§

type Output = i64

source§

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

source§

impl ValueGenerator for i128

§

type Output = i128

source§

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

source§

impl ValueGenerator for isize

§

type Output = isize

source§

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

source§

impl ValueGenerator for u8

§

type Output = u8

source§

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

source§

impl ValueGenerator for u16

§

type Output = u16

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 ValueGenerator for u64

§

type Output = u64

source§

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

source§

impl ValueGenerator for u128

§

type Output = u128

source§

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

source§

impl ValueGenerator for ()

§

type Output = ()

source§

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

source§

impl ValueGenerator for usize

§

type Output = usize

source§

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

source§

impl ValueGenerator for String

§

type Output = String

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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<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<T> ValueGenerator for PhantomData<T>

§

type Output = PhantomData<T>

source§

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

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<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<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<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<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<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<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<V: ValueGenerator> ValueGenerator for HashSet<V>
where V::Output: Sized + Hash + Eq,

§

type Output = HashSet<<V 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, 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<V: ValueGenerator, K: ValueGenerator> ValueGenerator for HashMap<K, V>
where K::Output: Sized + Hash + Eq,

§

type Output = HashMap<<K as ValueGenerator>::Output, <V as ValueGenerator>::Output>

source§

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

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<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<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<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)

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>