Trait bolero_engine::TypeGenerator

pub trait TypeGenerator: Sized {
    // Required method
    fn generate<D>(driver: &mut D) -> Option<Self>
       where D: Driver;

    // Provided methods
    fn mutate<D>(&mut self, driver: &mut D) -> Option<()>
       where D: Driver { ... }
    fn gen() -> TypeValueGenerator<Self> { ... }
}

Expand description

Generate a value for a given type

Required Methods§

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

Generates a value with the given driver

Provided Methods§

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

Mutates an existing value with the given driver

fn gen() -> TypeValueGenerator<Self>

Returns a generator for a given type

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

impl TypeGenerator for bool

fn generate<D>(driver: &mut D) -> Option<bool>
where D: Driver,

impl TypeGenerator for char

fn generate<D>(driver: &mut D) -> Option<char>
where D: Driver,

impl TypeGenerator for f32

fn generate<D>(driver: &mut D) -> Option<f32>
where D: Driver,

impl TypeGenerator for f64

fn generate<D>(driver: &mut D) -> Option<f64>
where D: Driver,

impl TypeGenerator for i8

fn generate<D>(driver: &mut D) -> Option<i8>
where D: Driver,

impl TypeGenerator for i16

fn generate<D>(driver: &mut D) -> Option<i16>
where D: Driver,

impl TypeGenerator for i32

fn generate<D>(driver: &mut D) -> Option<i32>
where D: Driver,

impl TypeGenerator for i64

fn generate<D>(driver: &mut D) -> Option<i64>
where D: Driver,

impl TypeGenerator for i128

fn generate<D>(driver: &mut D) -> Option<i128>
where D: Driver,

impl TypeGenerator for isize

fn generate<D>(driver: &mut D) -> Option<isize>
where D: Driver,

impl TypeGenerator for u8

fn generate<D>(driver: &mut D) -> Option<u8>
where D: Driver,

impl TypeGenerator for u16

fn generate<D>(driver: &mut D) -> Option<u16>
where D: Driver,

impl TypeGenerator for u32

fn generate<D>(driver: &mut D) -> Option<u32>
where D: Driver,

impl TypeGenerator for u64

fn generate<D>(driver: &mut D) -> Option<u64>
where D: Driver,

impl TypeGenerator for u128

fn generate<D>(driver: &mut D) -> Option<u128>
where D: Driver,

impl TypeGenerator for ()

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

impl TypeGenerator for usize

fn generate<D>(driver: &mut D) -> Option<usize>
where D: Driver,

impl TypeGenerator for NonZero<i8>

fn generate<D>(driver: &mut D) -> Option<NonZero<i8>>
where D: Driver,

impl TypeGenerator for NonZero<i16>

fn generate<D>(driver: &mut D) -> Option<NonZero<i16>>
where D: Driver,

impl TypeGenerator for NonZero<i32>

fn generate<D>(driver: &mut D) -> Option<NonZero<i32>>
where D: Driver,

impl TypeGenerator for NonZero<i64>

fn generate<D>(driver: &mut D) -> Option<NonZero<i64>>
where D: Driver,

impl TypeGenerator for NonZero<i128>

fn generate<D>(driver: &mut D) -> Option<NonZero<i128>>
where D: Driver,

impl TypeGenerator for NonZero<isize>

fn generate<D>(driver: &mut D) -> Option<NonZero<isize>>
where D: Driver,

impl TypeGenerator for NonZero<u8>

fn generate<D>(driver: &mut D) -> Option<NonZero<u8>>
where D: Driver,

impl TypeGenerator for NonZero<u16>

fn generate<D>(driver: &mut D) -> Option<NonZero<u16>>
where D: Driver,

impl TypeGenerator for NonZero<u32>

fn generate<D>(driver: &mut D) -> Option<NonZero<u32>>
where D: Driver,

impl TypeGenerator for NonZero<u64>

fn generate<D>(driver: &mut D) -> Option<NonZero<u64>>
where D: Driver,

impl TypeGenerator for NonZero<u128>

fn generate<D>(driver: &mut D) -> Option<NonZero<u128>>
where D: Driver,

impl TypeGenerator for NonZero<usize>

fn generate<D>(driver: &mut D) -> Option<NonZero<usize>>
where D: Driver,

impl TypeGenerator for AtomicBool

fn generate<D>(driver: &mut D) -> Option<AtomicBool>
where D: Driver,

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

impl TypeGenerator for AtomicI8

fn generate<D>(driver: &mut D) -> Option<AtomicI8>
where D: Driver,

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

impl TypeGenerator for AtomicI16

fn generate<D>(driver: &mut D) -> Option<AtomicI16>
where D: Driver,

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

impl TypeGenerator for AtomicI32

fn generate<D>(driver: &mut D) -> Option<AtomicI32>
where D: Driver,

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

impl TypeGenerator for AtomicI64

fn generate<D>(driver: &mut D) -> Option<AtomicI64>
where D: Driver,

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

impl TypeGenerator for AtomicIsize

fn generate<D>(driver: &mut D) -> Option<AtomicIsize>
where D: Driver,

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

impl TypeGenerator for AtomicU8

fn generate<D>(driver: &mut D) -> Option<AtomicU8>
where D: Driver,

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

impl TypeGenerator for AtomicU16

fn generate<D>(driver: &mut D) -> Option<AtomicU16>
where D: Driver,

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

impl TypeGenerator for AtomicU32

fn generate<D>(driver: &mut D) -> Option<AtomicU32>
where D: Driver,

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

impl TypeGenerator for AtomicU64

fn generate<D>(driver: &mut D) -> Option<AtomicU64>
where D: Driver,

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

impl TypeGenerator for AtomicUsize

fn generate<D>(driver: &mut D) -> Option<AtomicUsize>
where D: Driver,

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

impl TypeGenerator for Duration

fn generate<D>(driver: &mut D) -> Option<Duration>
where D: Driver,

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

impl<A> TypeGenerator for (A,)
where A: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<(A,)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator, AC: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator, AC: TypeGenerator, AD: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator, AC: TypeGenerator, AD: TypeGenerator, AE: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator, AC: TypeGenerator, AD: TypeGenerator, AE: TypeGenerator, AF: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

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

impl<B, A> TypeGenerator for (A, B)
where B: TypeGenerator, A: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<(A, B)>
where D_: Driver,

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

impl<C, A, B> TypeGenerator for (A, B, C)
where C: TypeGenerator, A: TypeGenerator, B: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<(A, B, C)>
where D_: Driver,

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

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

fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D)>
where D_: Driver,

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

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

fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E)>
where D_: Driver,

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

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

fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F)>
where D_: Driver,

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

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

fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G)>
where D_: Driver,

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

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

fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G, H)>
where D_: Driver,

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

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

fn generate<D_>(driver: &mut D_) -> Option<(A, B, C, D, E, F, G, H, I)>
where D_: Driver,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<Ok, Err> TypeGenerator for Result<Ok, Err>
where Ok: TypeGenerator, Err: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<Result<Ok, Err>>
where D: Driver,

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

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

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

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

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

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

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

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

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

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

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

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

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

impl<T> TypeGenerator for Cell<T>
where T: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<Cell<T>>
where D: Driver,

impl<T> TypeGenerator for RefCell<T>
where T: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<RefCell<T>>
where D: Driver,

impl<T> TypeGenerator for UnsafeCell<T>
where T: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<UnsafeCell<T>>
where D: Driver,

impl<T> TypeGenerator for PhantomData<T>

fn generate<D>(_driver: &mut D) -> Option<PhantomData<T>>
where D: Driver,

impl<T> TypeGenerator for Range<T>
where T: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<Range<T>>
where D: Driver,

impl<T> TypeGenerator for RangeInclusive<T>
where T: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<RangeInclusive<T>>
where D: Driver,

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

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

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

impl<T, const LEN: usize> TypeGenerator for [T; LEN]
where T: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<[T; LEN]>
where D: Driver,

fn mutate<D>(&mut self, driver: &mut D) -> 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> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)
where U: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

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

impl<V> TypeGenerator for Option<V>
where V: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<Option<V>>
where D: Driver,

fn mutate<D>(&mut self, driver: &mut D) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

fn mutate<D_>(&mut self, driver: &mut D_) -> 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> TypeGenerator 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: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator,

fn generate<D_>( 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)>
where D_: Driver,

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

Implementors§