Trait bolero::generator::TypeGeneratorWithParams

pub trait TypeGeneratorWithParams {
    type Output: ValueGenerator;
    fn gen_with() -> Self::Output;
}

Convert a type generator into the default value generator

Associated Types

type Output: ValueGenerator

Loading content...

Required methods

fn gen_with() -> Self::Output

Loading content...

Implementations on Foreign Types

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

type Output = LinkedListGenerator<TypeValueGenerator<V>, RangeInclusive<usize>>

fn gen_with() -> <LinkedList<V> as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for String

type Output = StringGenerator<TypeValueGenerator<char>, RangeInclusive<usize>>

fn gen_with() -> <String as TypeGeneratorWithParams>::Output

impl<J, A, B, C, D, E, F, G, H, I> TypeGeneratorWithParams 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, 

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroU128

type Output = BoundedGenerator<TypeValueGenerator<NonZeroU128>, RangeFrom<NonZeroU128>>

fn gen_with() -> <NonZeroU128 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 25]

fn gen_with() -> <[T; 25] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 2]

fn gen_with() -> <[T; 2] as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for ()

type Output = ()

fn gen_with() -> <() as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroIsize

type Output = BoundedGenerator<TypeValueGenerator<NonZeroIsize>, RangeFrom<NonZeroIsize>>

fn gen_with() -> <NonZeroIsize as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>, TypeValueGenerator<Z>, TypeValueGenerator<AA>, TypeValueGenerator<AB>, TypeValueGenerator<AC>, TypeValueGenerator<AD>, TypeValueGenerator<AE>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE) as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroI64

type Output = BoundedGenerator<TypeValueGenerator<NonZeroI64>, RangeFrom<NonZeroI64>>

fn gen_with() -> <NonZeroI64 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 22]

fn gen_with() -> <[T; 22] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 1]

fn gen_with() -> <[T; 1] as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroI16

type Output = BoundedGenerator<TypeValueGenerator<NonZeroI16>, RangeFrom<NonZeroI16>>

fn gen_with() -> <NonZeroI16 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 32]

fn gen_with() -> <[T; 32] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 26]

fn gen_with() -> <[T; 26] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicI64

type Output = BoundedGenerator<TypeValueGenerator<AtomicI64>, RangeFrom<i64>>

fn gen_with() -> <AtomicI64 as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for u16

type Output = BoundedGenerator<TypeValueGenerator<u16>, RangeFrom<u16>>

fn gen_with() -> <u16 as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for bool

type Output = BooleanGenerator

fn gen_with() -> <bool as TypeGeneratorWithParams>::Output

impl<L, A, B, C, D, E, F, G, H, I, J, K> TypeGeneratorWithParams 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, 

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicUsize

type Output = BoundedGenerator<TypeValueGenerator<AtomicUsize>, RangeFrom<usize>>

fn gen_with() -> <AtomicUsize as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicI32

type Output = BoundedGenerator<TypeValueGenerator<AtomicI32>, RangeFrom<i32>>

fn gen_with() -> <AtomicI32 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 11]

fn gen_with() -> <[T; 11] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 33]

fn gen_with() -> <[T; 33] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O) as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 20]

fn gen_with() -> <[T; 20] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 5]

fn gen_with() -> <[T; 5] as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroI8

type Output = BoundedGenerator<TypeValueGenerator<NonZeroI8>, RangeFrom<NonZeroI8>>

fn gen_with() -> <NonZeroI8 as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for Duration

type Output = DurationGenerator<TypeValueGenerator<u64>, Range<u32>>

fn gen_with() -> <Duration as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 6]

fn gen_with() -> <[T; 6] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>, TypeValueGenerator<Z>, TypeValueGenerator<AA>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA) as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 19]

fn gen_with() -> <[T; 19] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>)

fn gen_with() -> <(A, B, C, D, E) as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 13]

fn gen_with() -> <[T; 13] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for isize

type Output = BoundedGenerator<TypeValueGenerator<isize>, RangeFrom<isize>>

fn gen_with() -> <isize as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for i16

type Output = BoundedGenerator<TypeValueGenerator<i16>, RangeFrom<i16>>

fn gen_with() -> <i16 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 14]

fn gen_with() -> <[T; 14] as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroI32

type Output = BoundedGenerator<TypeValueGenerator<NonZeroI32>, RangeFrom<NonZeroI32>>

fn gen_with() -> <NonZeroI32 as TypeGeneratorWithParams>::Output

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

type Output = BinaryHeapGenerator<TypeValueGenerator<V>, RangeInclusive<usize>>

fn gen_with() -> <BinaryHeap<V> as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for usize

type Output = BoundedGenerator<TypeValueGenerator<usize>, RangeFrom<usize>>

fn gen_with() -> <usize as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>)

fn gen_with() -> <(A, B) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for u32

type Output = BoundedGenerator<TypeValueGenerator<u32>, RangeFrom<u32>>

fn gen_with() -> <u32 as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>)

fn gen_with() -> <(A, B, C, D, E, F, G) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicU32

type Output = BoundedGenerator<TypeValueGenerator<AtomicU32>, RangeFrom<u32>>

fn gen_with() -> <AtomicU32 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 29]

fn gen_with() -> <[T; 29] as TypeGeneratorWithParams>::Output

impl<T> TypeGeneratorWithParams for [T; 0]

type Output = [T; 0]

fn gen_with() -> <[T; 0] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X) as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicU8

type Output = BoundedGenerator<TypeValueGenerator<AtomicU8>, RangeFrom<u8>>

fn gen_with() -> <AtomicU8 as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroU8

type Output = BoundedGenerator<TypeValueGenerator<NonZeroU8>, RangeFrom<NonZeroU8>>

fn gen_with() -> <NonZeroU8 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 31]

fn gen_with() -> <[T; 31] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>, TypeValueGenerator<Z>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for i128

type Output = BoundedGenerator<TypeValueGenerator<i128>, RangeFrom<i128>>

fn gen_with() -> <i128 as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>)

fn gen_with() -> <(A, B, C, D) as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 7]

fn gen_with() -> <[T; 7] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>,)

fn gen_with() -> <(A,) as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 10]

fn gen_with() -> <[T; 10] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 12]

fn gen_with() -> <[T; 12] as TypeGeneratorWithParams>::Output

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

type Output = VecGenerator<TypeValueGenerator<V>, RangeInclusive<usize>>

fn gen_with() -> <Vec<V> as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 28]

fn gen_with() -> <[T; 28] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 23]

fn gen_with() -> <[T; 23] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 24]

fn gen_with() -> <[T; 24] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>, TypeValueGenerator<Z>, TypeValueGenerator<AA>, TypeValueGenerator<AB>, TypeValueGenerator<AC>, TypeValueGenerator<AD>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD) as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M) as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 21]

fn gen_with() -> <[T; 21] as TypeGeneratorWithParams>::Output

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

type Output = OptionGenerator<TypeValueGenerator<V>, TypeValueGenerator<bool>>

fn gen_with() -> <Option<V> as TypeGeneratorWithParams>::Output

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

type Output = HashSetGenerator<TypeValueGenerator<V>, RangeInclusive<usize>>

fn gen_with() -> <HashSet<V, RandomState> as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>, TypeValueGenerator<Z>, TypeValueGenerator<AA>, TypeValueGenerator<AB>, TypeValueGenerator<AC>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC) as TypeGeneratorWithParams>::Output

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

type Output = RangeGenerator<TypeValueGenerator<T>, TypeValueGenerator<T>>

fn gen_with() -> <Range<T> as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 9]

fn gen_with() -> <[T; 9] as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for u128

type Output = BoundedGenerator<TypeValueGenerator<u128>, RangeFrom<u128>>

fn gen_with() -> <u128 as TypeGeneratorWithParams>::Output

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

type Output = BTreeMapGenerator<TypeValueGenerator<K>, TypeValueGenerator<V>, RangeInclusive<usize>>

fn gen_with() -> <BTreeMap<K, V> as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for i64

type Output = BoundedGenerator<TypeValueGenerator<i64>, RangeFrom<i64>>

fn gen_with() -> <i64 as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicI16

type Output = BoundedGenerator<TypeValueGenerator<AtomicI16>, RangeFrom<i16>>

fn gen_with() -> <AtomicI16 as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for i32

type Output = BoundedGenerator<TypeValueGenerator<i32>, RangeFrom<i32>>

fn gen_with() -> <i32 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 15]

fn gen_with() -> <[T; 15] as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for char

type Output = BoundedGenerator<TypeValueGenerator<char>, Range<char>>

fn gen_with() -> <char as TypeGeneratorWithParams>::Output

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

type Output = HashMapGenerator<TypeValueGenerator<K>, TypeValueGenerator<V>, RangeInclusive<usize>>

fn gen_with() -> <HashMap<K, V, RandomState> as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>, TypeValueGenerator<Z>, TypeValueGenerator<AA>, TypeValueGenerator<AB>, TypeValueGenerator<AC>, TypeValueGenerator<AD>, TypeValueGenerator<AE>, TypeValueGenerator<AF>, TypeValueGenerator<AG>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF, AG) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for u64

type Output = BoundedGenerator<TypeValueGenerator<u64>, RangeFrom<u64>>

fn gen_with() -> <u64 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 27]

fn gen_with() -> <[T; 27] as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for i8

type Output = BoundedGenerator<TypeValueGenerator<i8>, RangeFrom<i8>>

fn gen_with() -> <i8 as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W) as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 8]

fn gen_with() -> <[T; 8] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>, TypeValueGenerator<Z>, TypeValueGenerator<AA>, TypeValueGenerator<AB>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicU16

type Output = BoundedGenerator<TypeValueGenerator<AtomicU16>, RangeFrom<u16>>

fn gen_with() -> <AtomicU16 as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroI128

type Output = BoundedGenerator<TypeValueGenerator<NonZeroI128>, RangeFrom<NonZeroI128>>

fn gen_with() -> <NonZeroI128 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 18]

fn gen_with() -> <[T; 18] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroU32

type Output = BoundedGenerator<TypeValueGenerator<NonZeroU32>, RangeFrom<NonZeroU32>>

fn gen_with() -> <NonZeroU32 as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 16]

fn gen_with() -> <[T; 16] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicIsize

type Output = BoundedGenerator<TypeValueGenerator<AtomicIsize>, RangeFrom<isize>>

fn gen_with() -> <AtomicIsize as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for u8

type Output = BoundedGenerator<TypeValueGenerator<u8>, RangeFrom<u8>>

fn gen_with() -> <u8 as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroU64

type Output = BoundedGenerator<TypeValueGenerator<NonZeroU64>, RangeFrom<NonZeroU64>>

fn gen_with() -> <NonZeroU64 as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>, TypeValueGenerator<R>, TypeValueGenerator<S>, TypeValueGenerator<T>, TypeValueGenerator<U>, TypeValueGenerator<V>, TypeValueGenerator<W>, TypeValueGenerator<X>, TypeValueGenerator<Y>, TypeValueGenerator<Z>, TypeValueGenerator<AA>, TypeValueGenerator<AB>, TypeValueGenerator<AC>, TypeValueGenerator<AD>, TypeValueGenerator<AE>, TypeValueGenerator<AF>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z, AA, AB, AC, AD, AE, AF) as TypeGeneratorWithParams>::Output

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

type Output = ResultGenerator<TypeValueGenerator<Ok>, TypeValueGenerator<Err>, TypeValueGenerator<bool>>

fn gen_with() -> <Result<Ok, Err> as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroUsize

type Output = BoundedGenerator<TypeValueGenerator<NonZeroUsize>, RangeFrom<NonZeroUsize>>

fn gen_with() -> <NonZeroUsize as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 30]

fn gen_with() -> <[T; 30] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 17]

fn gen_with() -> <[T; 17] as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 3]

fn gen_with() -> <[T; 3] as TypeGeneratorWithParams>::Output

impl<K, A, B, C, D, E, F, G, H, I, J> TypeGeneratorWithParams 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, 

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for NonZeroU16

type Output = BoundedGenerator<TypeValueGenerator<NonZeroU16>, RangeFrom<NonZeroU16>>

fn gen_with() -> <NonZeroU16 as TypeGeneratorWithParams>::Output

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

type Output = BTreeSetGenerator<TypeValueGenerator<V>, RangeInclusive<usize>>

fn gen_with() -> <BTreeSet<V> as TypeGeneratorWithParams>::Output

impl<H, A, B, C, D, E, F, G> TypeGeneratorWithParams 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, 

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>)

fn gen_with() -> <(A, B, C, D, E, F, G, H) as TypeGeneratorWithParams>::Output

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

type Output = RangeInclusiveGenerator<TypeValueGenerator<T>, TypeValueGenerator<T>>

fn gen_with() -> <RangeInclusive<T> as TypeGeneratorWithParams>::Output

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

type Output = VecDequeGenerator<TypeValueGenerator<V>, RangeInclusive<usize>>

fn gen_with() -> <VecDeque<V> as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>, TypeValueGenerator<O>, TypeValueGenerator<P>, TypeValueGenerator<Q>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicU64

type Output = BoundedGenerator<TypeValueGenerator<AtomicU64>, RangeFrom<u64>>

fn gen_with() -> <AtomicU64 as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>)

fn gen_with() -> <(A, B, C) as TypeGeneratorWithParams>::Output

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

type Output = EitherGenerator<TypeValueGenerator<Left>, TypeValueGenerator<Right>, TypeValueGenerator<bool>>

fn gen_with() -> <Either<Left, Right> as TypeGeneratorWithParams>::Output

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

type Output = [TypeValueGenerator<T>; 4]

fn gen_with() -> <[T; 4] as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>)

fn gen_with() -> <(A, B, C, D, E, F) as TypeGeneratorWithParams>::Output

impl<I, A, B, C, D, E, F, G, H> TypeGeneratorWithParams 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, 

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I) as TypeGeneratorWithParams>::Output

impl TypeGeneratorWithParams for AtomicI8

type Output = BoundedGenerator<TypeValueGenerator<AtomicI8>, RangeFrom<i8>>

fn gen_with() -> <AtomicI8 as TypeGeneratorWithParams>::Output

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator<B>, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator<I>, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>, TypeValueGenerator<M>, TypeValueGenerator<N>)

fn gen_with(
) -> <(A, B, C, D, E, F, G, H, I, J, K, L, M, N) as TypeGeneratorWithParams>::Output

Loading content...

Implementors

Loading content...