Trait bolero_engine::TypeGenerator

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

    fn gen() -> TypeValueGenerator<Self> { ... }
}

Generate a value for a given type

Required methods

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

Loading content...

Provided methods

fn gen() -> TypeValueGenerator<Self>

Returns a generator for a given type

Loading content...

Implementations on Foreign Types

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
    A: TypeGenerator,
    AA: TypeGenerator,
    AB: TypeGenerator,
    AC: TypeGenerator,
    AD: 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, AB, AC, AD)> where
    D_: Driver, 

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

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

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

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

impl TypeGenerator for NonZeroI8

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

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

impl TypeGenerator for NonZeroI64

fn generate<D>(driver: &mut D) -> Option<NonZeroI64> 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
    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)> where
    D_: Driver, 

impl TypeGenerator for NonZeroU8

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

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

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

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

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

impl TypeGenerator for AtomicI16

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

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

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

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

impl TypeGenerator for AtomicUsize

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

impl TypeGenerator for char

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

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

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

impl TypeGenerator for isize

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

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

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

impl TypeGenerator for i32

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

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

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

impl TypeGenerator for AtomicU16

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

impl TypeGenerator for AtomicBool

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

impl TypeGenerator for NonZeroU64

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

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

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

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

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

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

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

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

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

impl TypeGenerator for AtomicI64

fn generate<D>(driver: &mut D) -> Option<AtomicI64> 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
    A: TypeGenerator,
    AA: TypeGenerator,
    AB: TypeGenerator,
    AC: 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, AB, AC)> 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
    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)> 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 Box<str>

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

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

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

impl TypeGenerator for String

fn generate<D>(driver: &mut D) -> Option<String> 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
    A: TypeGenerator,
    AA: TypeGenerator,
    AB: TypeGenerator,
    AC: TypeGenerator,
    AD: TypeGenerator,
    AE: 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, AB, AC, AD, AE)> where
    D_: Driver, 

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

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

impl TypeGenerator for usize

fn generate<D>(driver: &mut D) -> Option<usize> 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
    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)> where
    D_: Driver, 

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

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

impl<T> TypeGenerator for [T; 0]

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

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

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

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

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

impl TypeGenerator for AtomicI32

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

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

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

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

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

impl TypeGenerator for u8

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

impl TypeGenerator for i128

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

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

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

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

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

impl TypeGenerator for Duration

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

impl TypeGenerator for NonZeroU32

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

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

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

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

impl TypeGenerator for NonZeroU128

fn generate<D>(driver: &mut D) -> Option<NonZeroU128> 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<I, A, B, C, D, E, F, G, H> TypeGenerator for (A, B, C, D, E, F, G, H, I) where
    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)> 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
    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)> where
    D_: Driver, 

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl TypeGenerator for NonZeroIsize

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

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

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

impl TypeGenerator for NonZeroI128

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

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

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

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

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

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

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

impl TypeGenerator for u16

fn generate<D>(driver: &mut D) -> Option<u16> 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
    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)> where
    D_: Driver, 

impl TypeGenerator for NonZeroU16

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

impl TypeGenerator for NonZeroUsize

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

impl TypeGenerator for u128

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

impl TypeGenerator for f32

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

impl TypeGenerator for AtomicU8

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

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

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

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

impl TypeGenerator for AtomicU64

fn generate<D>(driver: &mut D) -> Option<AtomicU64> 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
    A: TypeGenerator,
    AA: TypeGenerator,
    AB: 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, AB)> 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, 

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

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

impl TypeGenerator for f64

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

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

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

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

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

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

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

impl<H, A, B, C, D, E, F, G> TypeGenerator for (A, B, C, D, E, F, G, H) where
    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)> where
    D_: Driver, 

impl TypeGenerator for u64

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

impl TypeGenerator for AtomicI8

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

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

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

impl TypeGenerator for i64

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

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

fn generate<D_>(driver: &mut D_) -> Option<[T; 2]> 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
    A: TypeGenerator,
    AA: TypeGenerator,
    AB: TypeGenerator,
    AC: TypeGenerator,
    AD: TypeGenerator,
    AE: TypeGenerator,
    AF: 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, AB, AC, AD, AE, AF)> where
    D_: Driver, 

impl<T> TypeGenerator for PhantomData<T>

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

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

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

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

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

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

fn generate<D>(driver: &mut D) -> Option<Rc<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
    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)> 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
    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)> where
    D_: Driver, 

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

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

impl TypeGenerator for AtomicU32

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

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

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

impl<G, A, B, C, D, E, F> TypeGenerator for (A, B, C, D, E, F, G) where
    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)> where
    D_: Driver, 

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

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

impl TypeGenerator for u32

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

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

fn generate<D_>(driver: &mut D_) -> Option<[T; 8]> 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
    A: TypeGenerator,
    AA: TypeGenerator,
    AB: TypeGenerator,
    AC: TypeGenerator,
    AD: TypeGenerator,
    AE: TypeGenerator,
    AF: TypeGenerator,
    AG: 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, AB, AC, AD, AE, AF, AG)> where
    D_: Driver, 

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

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

impl TypeGenerator for i8

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

impl<F, A, B, C, D, E> TypeGenerator for (A, B, C, D, E, F) where
    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)> where
    D_: Driver, 

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

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

impl TypeGenerator for i16

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

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

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

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

impl TypeGenerator for NonZeroI16

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

impl TypeGenerator for ()

fn generate<D>(_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, 

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

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

Loading content...

Implementors

Loading content...