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

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

Generate a value for a given type

Required Methods§

source

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

Generates a value with the given driver

Provided Methods§

source

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

Mutates an existing value with the given driver

source

fn gen() -> TypeValueGenerator<Self>

Returns a generator for a given type

Object Safety§

This trait is not object safe.

Implementations on Foreign Types§

source§

impl TypeGenerator for bool

source§

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

source§

impl TypeGenerator for char

source§

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

source§

impl TypeGenerator for f32

source§

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

source§

impl TypeGenerator for f64

source§

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

source§

impl TypeGenerator for i8

source§

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

source§

impl TypeGenerator for i16

source§

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

source§

impl TypeGenerator for i32

source§

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

source§

impl TypeGenerator for i64

source§

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

source§

impl TypeGenerator for i128

source§

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

source§

impl TypeGenerator for isize

source§

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

source§

impl TypeGenerator for u8

source§

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

source§

impl TypeGenerator for u16

source§

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

source§

impl TypeGenerator for u32

source§

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

source§

impl TypeGenerator for u64

source§

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

source§

impl TypeGenerator for u128

source§

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

source§

impl TypeGenerator for ()

source§

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

source§

impl TypeGenerator for usize

source§

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

source§

impl TypeGenerator for Box<str>

source§

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

source§

impl TypeGenerator for String

source§

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

source§

impl TypeGenerator for AtomicBool

source§

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

source§

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

source§

impl TypeGenerator for AtomicI8

source§

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

source§

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

source§

impl TypeGenerator for AtomicI16

source§

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

source§

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

source§

impl TypeGenerator for AtomicI32

source§

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

source§

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

source§

impl TypeGenerator for AtomicI64

source§

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

source§

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

source§

impl TypeGenerator for AtomicIsize

source§

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

source§

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

source§

impl TypeGenerator for AtomicU8

source§

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

source§

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

source§

impl TypeGenerator for AtomicU16

source§

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

source§

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

source§

impl TypeGenerator for AtomicU32

source§

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

source§

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

source§

impl TypeGenerator for AtomicU64

source§

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

source§

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

source§

impl TypeGenerator for AtomicUsize

source§

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

source§

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

source§

impl TypeGenerator for Duration

source§

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

source§

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

source§

impl TypeGenerator for NonZeroI8

source§

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

source§

impl TypeGenerator for NonZeroI16

source§

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

source§

impl TypeGenerator for NonZeroI32

source§

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

source§

impl TypeGenerator for NonZeroI64

source§

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

source§

impl TypeGenerator for NonZeroI128

source§

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

source§

impl TypeGenerator for NonZeroIsize

source§

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

source§

impl TypeGenerator for NonZeroU8

source§

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

source§

impl TypeGenerator for NonZeroU16

source§

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

source§

impl TypeGenerator for NonZeroU32

source§

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

source§

impl TypeGenerator for NonZeroU64

source§

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

source§

impl TypeGenerator for NonZeroU128

source§

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

source§

impl TypeGenerator for NonZeroUsize

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<K: TypeGenerator + Hash + Eq, V: TypeGenerator> TypeGenerator for HashMap<K, V>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<Left: TypeGenerator, Right: TypeGenerator> TypeGenerator for Either<Left, Right>

source§

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

source§

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

source§

impl<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> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M)

source§

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

source§

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

source§

impl<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> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)

source§

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

source§

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

source§

impl<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> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<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> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)

source§

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

source§

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

source§

impl<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> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

source§

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

source§

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

source§

impl<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> TypeGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T> TypeGenerator for PhantomData<T>

source§

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

source§

impl<T: TypeGenerator> TypeGenerator for Box<[T]>

source§

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

source§

impl<T: TypeGenerator> TypeGenerator for Box<T>

source§

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

source§

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

source§

impl<T: TypeGenerator> TypeGenerator for Rc<T>

source§

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

source§

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

source§

impl<T: TypeGenerator> TypeGenerator for Arc<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<T: TypeGenerator> TypeGenerator for Mutex<T>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

impl<V: TypeGenerator + Hash + Eq> TypeGenerator for HashSet<V>

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

source§

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

Implementors§