Trait bolero::generator::TypeGenerator

source · [−]

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

    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

Implementations on Foreign Types

impl<T> TypeGenerator for [T; 9]where
T: TypeGenerator,

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

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

impl TypeGenerator for u32

fn generate<D>(driver: &mut D) -> Option<u32>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 [T; 31]where
T: TypeGenerator,

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

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

impl<V> TypeGenerator for Vec<V, Global>where
V: TypeGenerator,

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

fn mutate<D>(&mut self, driver: &mut D) -> Option<()>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> TypeGenerator for [T; 5]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 5]>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 TypeGenerator for NonZeroU64

fn generate<D>(driver: &mut D) -> Option<NonZeroU64>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<T> TypeGenerator for [T; 0]

fn generate<D_>(_driver: &mut D_) -> Option<[T; 0]>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 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 NonZeroUsize

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

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

fn generate<D>(driver: &mut D) -> Option<Arc<T>>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<V> TypeGenerator for BTreeSet<V, Global>where
V: TypeGenerator + Ord,

fn generate<D>(driver: &mut D) -> Option<BTreeSet<V, Global>>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<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<T> TypeGenerator for [T; 11]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 24]where
T: TypeGenerator,

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

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

impl TypeGenerator for NonZeroU128

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

impl<T> TypeGenerator for [T; 25]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 25]>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 TypeGenerator for bool

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

impl<V> TypeGenerator for BinaryHeap<V>where
V: TypeGenerator + Ord,

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

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

impl<T> TypeGenerator for [T; 29]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 28]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 28]>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<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<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 TypeGenerator for i64

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

impl TypeGenerator for NonZeroI16

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

impl TypeGenerator for NonZeroI8

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

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

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

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

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

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

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

impl<K, V> TypeGenerator for BTreeMap<K, V, Global>where
K: TypeGenerator + Ord,
V: TypeGenerator,

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

impl<T> TypeGenerator for [T; 4]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 4]>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<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<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<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<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 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<T> TypeGenerator for [T; 23]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 23]>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,

impl<T> TypeGenerator for [T; 17]where
T: TypeGenerator,

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

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

impl TypeGenerator for isize

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

impl TypeGenerator for char

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

impl TypeGenerator for NonZeroU16

fn generate<D>(driver: &mut D) -> Option<NonZeroU16>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> TypeGenerator for [T; 15]where
T: TypeGenerator,

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

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

impl TypeGenerator for u16

fn generate<D>(driver: &mut D) -> Option<u16>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 [T; 32]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 10]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 26]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for Box<[T], Global>where
T: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<Box<[T], Global>>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<V> TypeGenerator for VecDeque<V, Global>where
V: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 8]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 8]>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<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 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<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<T> TypeGenerator for Mutex<T>where
T: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<Mutex<T>>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<K, V> TypeGenerator for HashMap<K, V, RandomState>where
K: TypeGenerator + Hash + Eq,
V: TypeGenerator,

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

impl TypeGenerator for i8

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

impl<T> TypeGenerator for [T; 7]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 7]>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 TypeGenerator for NonZeroIsize

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

impl TypeGenerator for NonZeroI128

fn generate<D>(driver: &mut D) -> Option<NonZeroI128>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 f64

fn generate<D>(driver: &mut D) -> Option<f64>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<T> TypeGenerator for [T; 16]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 16]>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 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<T> TypeGenerator for [T; 1]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 1]>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 TypeGenerator for f32

fn generate<D>(driver: &mut D) -> Option<f32>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<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 TypeGenerator for u64

fn generate<D>(driver: &mut D) -> Option<u64>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 [T; 27]where
T: TypeGenerator,

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

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

impl TypeGenerator for i32

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

impl TypeGenerator for NonZeroI32

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

impl<T> TypeGenerator for [T; 6]where
T: TypeGenerator,

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

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

impl TypeGenerator for Box<str, Global>

fn generate<D>(driver: &mut D) -> Option<Box<str, Global>>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<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 TypeGenerator for NonZeroU32

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

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

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

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

impl TypeGenerator for i128

fn generate<D>(driver: &mut D) -> Option<i128>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<T> TypeGenerator for [T; 30]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for Cow<'static, T>where
T: ToOwned + ?Sized,
<T as ToOwned>::Owned: TypeGenerator,

fn generate<D>(driver: &mut D) -> Option<Cow<'static, T>>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 TypeGenerator for usize

fn generate<D>(driver: &mut D) -> Option<usize>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 u128

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

impl TypeGenerator for u8

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

impl<T> TypeGenerator for [T; 13]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 12]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 14]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 14]>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<T> TypeGenerator for [T; 21]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 22]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 2]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for PhantomData<T>

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

impl TypeGenerator for ()

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

impl<T> TypeGenerator for [T; 19]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 19]>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<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<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 TypeGenerator for NonZeroI64

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

impl TypeGenerator for String

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

impl<T> TypeGenerator for [T; 20]where
T: TypeGenerator,

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

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

impl TypeGenerator for NonZeroU8

fn generate<D>(driver: &mut D) -> Option<NonZeroU8>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 i16

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

impl<T> TypeGenerator for Box<T, Global>where
T: TypeGenerator,

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

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

impl<V> TypeGenerator for HashSet<V, RandomState>where
V: TypeGenerator + Hash + Eq,

fn generate<D>(driver: &mut D) -> Option<HashSet<V, RandomState>>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<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<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<T> TypeGenerator for [T; 33]where
T: TypeGenerator,

fn generate<D_>(driver: &mut D_) -> Option<[T; 33]>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<T> TypeGenerator for [T; 18]where
T: TypeGenerator,

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

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

impl<T> TypeGenerator for [T; 3]where
T: TypeGenerator,

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

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

Implementors