Trait bolero_engine::ValueGenerator

pub trait ValueGenerator: Sized {
    type Output;

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

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

Generate a value with a parameterized generator

Required Associated Types

type Output

Required Methods

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

where D: Driver,

Generates a value with the given driver

Provided Methods

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

where D: Driver,

Mutates an existing value with the given driver

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

where F: Fn(Self::Output) -> T,

Map the value of a generator

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

where F: Fn(Self::Output) -> T, T: ValueGenerator,

Map the value of a generator with a new generator

fn filter_gen<F>(self, filter: F) -> FilterGenerator<Self, F>

where F: Fn(&Self::Output) -> bool,

Filter the value of a generator

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

where F: Fn(Self::Output) -> Option<T>,

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

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl ValueGenerator for bool

type Output = bool

fn generate<D>( &self, _driver: &mut D ) -> Option<<bool as ValueGenerator>::Output>

where D: Driver,

impl ValueGenerator for char

type Output = char

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

where D: Driver,

impl ValueGenerator for f32

type Output = f32

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

where D: Driver,

impl ValueGenerator for f64

type Output = f64

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

where D: Driver,

impl ValueGenerator for i8

type Output = i8

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

where D: Driver,

impl ValueGenerator for i16

type Output = i16

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

where D: Driver,

impl ValueGenerator for i32

type Output = i32

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

where D: Driver,

impl ValueGenerator for i64

type Output = i64

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

where D: Driver,

impl ValueGenerator for i128

type Output = i128

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

where D: Driver,

impl ValueGenerator for isize

type Output = isize

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

where D: Driver,

impl ValueGenerator for u8

type Output = u8

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

where D: Driver,

impl ValueGenerator for u16

type Output = u16

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

where D: Driver,

impl ValueGenerator for u32

type Output = u32

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

where D: Driver,

impl ValueGenerator for u64

type Output = u64

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

where D: Driver,

impl ValueGenerator for u128

type Output = u128

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

where D: Driver,

impl ValueGenerator for ()

type Output = ()

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

where D: Driver,

impl ValueGenerator for usize

type Output = usize

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

where D: Driver,

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

where T: ValueGenerator,

type Output = <T as ValueGenerator>::Output

fn generate<D>( &self, driver: &mut D ) -> Option<<&'a T as ValueGenerator>::Output>

where D: Driver,

fn mutate<D>( &self, driver: &mut D, value: &mut <&'a T as ValueGenerator>::Output ) -> Option<()>

where D: Driver,

impl<A> ValueGenerator for (A,)

where A: ValueGenerator,

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

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A,) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A,) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<AA, 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> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<AB, 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> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<AC, 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> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<AD, 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> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<AE, 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> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<AF, 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> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output, <AF as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<AG, 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> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output, <AA as ValueGenerator>::Output, <AB as ValueGenerator>::Output, <AC as ValueGenerator>::Output, <AD as ValueGenerator>::Output, <AE as ValueGenerator>::Output, <AF as ValueGenerator>::Output, <AG as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where B: ValueGenerator, A: ValueGenerator,

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

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where C: ValueGenerator, A: ValueGenerator, B: ValueGenerator,

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

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where D: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator,

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

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where E: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator,

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

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where F: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where G: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where G: ValueGenerator,

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

fn generate<D>( &self, driver: &mut D ) -> Option<<[G; LEN] as ValueGenerator>::Output>

where D: Driver,

fn mutate<D>( &self, driver: &mut D, value: &mut <[G; LEN] as ValueGenerator>::Output ) -> Option<()>

where D: Driver,

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

where H: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where I: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where J: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where K: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where L: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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, <R as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<T> ValueGenerator for PhantomData<T>

type Output = PhantomData<T>

fn generate<D>( &self, _driver: &mut D ) -> Option<<PhantomData<T> as ValueGenerator>::Output>

where D: Driver,

impl<T> ValueGenerator for Range<T>

where T: BoundedValue,

type Output = T

fn generate<D>( &self, driver: &mut D ) -> Option<<Range<T> as ValueGenerator>::Output>

where D: Driver,

fn mutate<D>( &self, driver: &mut D, value: &mut <Range<T> as ValueGenerator>::Output ) -> Option<()>

where D: Driver,

impl<T> ValueGenerator for RangeFrom<T>

where T: BoundedValue,

type Output = T

fn generate<D>( &self, driver: &mut D ) -> Option<<RangeFrom<T> as ValueGenerator>::Output>

where D: Driver,

fn mutate<D>( &self, driver: &mut D, value: &mut <RangeFrom<T> as ValueGenerator>::Output ) -> Option<()>

where D: Driver,

impl<T> ValueGenerator for RangeInclusive<T>

where T: BoundedValue,

type Output = T

fn generate<D>( &self, driver: &mut D ) -> Option<<RangeInclusive<T> as ValueGenerator>::Output>

where D: Driver,

fn mutate<D>( &self, driver: &mut D, value: &mut <RangeInclusive<T> as ValueGenerator>::Output ) -> Option<()>

where D: Driver,

impl<T> ValueGenerator for RangeTo<T>

where T: BoundedValue,

type Output = T

fn generate<D>( &self, driver: &mut D ) -> Option<<RangeTo<T> as ValueGenerator>::Output>

where D: Driver,

fn mutate<D>( &self, driver: &mut D, value: &mut <RangeTo<T> as ValueGenerator>::Output ) -> Option<()>

where D: Driver,

impl<T> ValueGenerator for RangeToInclusive<T>

where T: BoundedValue,

type Output = T

fn generate<D>( &self, driver: &mut D ) -> Option<<RangeToInclusive<T> as ValueGenerator>::Output>

where D: Driver,

fn mutate<D>( &self, driver: &mut D, value: &mut <RangeToInclusive<T> as ValueGenerator>::Output ) -> Option<()>

where D: Driver,

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

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

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

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<W, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<X, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<Y, A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

impl<Z, 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> 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)

where 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,

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, <R as ValueGenerator>::Output, <S as ValueGenerator>::Output, <T as ValueGenerator>::Output, <U as ValueGenerator>::Output, <V as ValueGenerator>::Output, <W as ValueGenerator>::Output, <X as ValueGenerator>::Output, <Y as ValueGenerator>::Output, <Z as ValueGenerator>::Output)

fn generate<D_>( &self, driver: &mut D_ ) -> Option<<(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) as ValueGenerator>::Output>

where D_: Driver,

fn mutate<D_>( &self, driver: &mut D_, value: &mut <(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) as ValueGenerator>::Output ) -> Option<()>

where D_: Driver,

Implementors

impl ValueGenerator for BooleanGenerator

type Output = bool

impl<G, F> ValueGenerator for FilterGenerator<G, F>

where G: ValueGenerator, F: Fn(&<G as ValueGenerator>::Output) -> bool,

type Output = <G as ValueGenerator>::Output

impl<G, F, T> ValueGenerator for FilterMapGenerator<G, F>

where G: ValueGenerator, F: Fn(<G as ValueGenerator>::Output) -> Option<T>,

type Output = T

impl<G, H, F> ValueGenerator for AndThenGenerator<G, F>

where G: ValueGenerator, H: ValueGenerator, F: Fn(<G as ValueGenerator>::Output) -> H,

type Output = <H as ValueGenerator>::Output

impl<G, M, T> ValueGenerator for MapGenerator<G, M>

where G: ValueGenerator, M: Fn(<G as ValueGenerator>::Output) -> T,

type Output = T

impl<O> ValueGenerator for OneOf<O>

where O: OneOfGenerator,

type Output = <O as OneOfGenerator>::Output

impl<O> ValueGenerator for OneValueOf<O>

where O: OneValueOfGenerator,

type Output = <O as OneValueOfGenerator>::Output

impl<Ok, Err, Selector> ValueGenerator for ResultGenerator<Ok, Err, Selector>

where Ok: ValueGenerator, Err: ValueGenerator, Selector: ValueGenerator<Output = bool>,

type Output = Result<<Ok as ValueGenerator>::Output, <Err as ValueGenerator>::Output>

impl<Seconds, Nanos> ValueGenerator for DurationGenerator<Seconds, Nanos>

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

type Output = Duration

impl<Start, End, T> ValueGenerator for RangeGenerator<Start, End>

where Start: ValueGenerator<Output = T>, End: ValueGenerator<Output = T>,

type Output = Range<T>

impl<Start, End, T> ValueGenerator for RangeInclusiveGenerator<Start, End>

where Start: ValueGenerator<Output = T>, End: ValueGenerator<Output = T>,

type Output = RangeInclusive<T>

impl<T> ValueGenerator for Constant<T>

where T: Clone,

type Output = T

impl<T> ValueGenerator for TypeValueGenerator<T>

where T: TypeGenerator,

type Output = T

impl<T, B> ValueGenerator for BoundedGenerator<T, B>

where T: BoundedValue, B: RangeBounds<T>,

type Output = T

impl<V, Selector> ValueGenerator for OptionGenerator<V, Selector>

where V: ValueGenerator, Selector: ValueGenerator<Output = bool>,

type Output = Option<<V as ValueGenerator>::Output>