Trait bolero::generator::TypeGeneratorWithParams

source · [−]

pub trait TypeGeneratorWithParams {
    type Output: ValueGenerator;

    fn gen_with() -> Self::Output;
}

Expand description

Convert a type generator into the default value generator

Required Associated Types

source

type Output: ValueGenerator

Required Methods

source

fn gen_with() -> Self::Output

Implementations on Foreign Types

source

impl TypeGeneratorWithParams for NonZeroI128

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

source

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

source

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

type Output = (TypeValueGenerator<A>, TypeValueGenerator)

source

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

source

impl TypeGeneratorWithParams for NonZeroI16

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 3]

source

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

source

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

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

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for i16

type Output = BoundedGenerator<i16, RangeFull>

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for AtomicUsize

type Output = BoundedGenerator<AtomicUsize, RangeFull>

source

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

source

impl TypeGeneratorWithParams for NonZeroU128

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

source

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

source

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

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

source

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

source

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

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

source

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

source

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

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

source

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

source

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

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

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for f64

type Output = BoundedGenerator<f64, RangeFull>

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for u8

type Output = BoundedGenerator<u8, RangeFull>

source

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

source

impl TypeGeneratorWithParams for isize

type Output = BoundedGenerator<isize, RangeFull>

source

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

source

impl TypeGeneratorWithParams for AtomicI32

type Output = BoundedGenerator<AtomicI32, RangeFull>

source

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

source

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

type Output = [TypeValueGenerator<T>; 31]

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 5]

source

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

source

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

type Output = [TypeValueGenerator<T>; 13]

source

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

source

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

type Output = [TypeValueGenerator<T>; 12]

source

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

source

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

type Output = [TypeValueGenerator<T>; 8]

source

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

source

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

type Output = [TypeValueGenerator<T>; 17]

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for NonZeroU64

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 11]

source

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

source

impl TypeGeneratorWithParams for AtomicU64

type Output = BoundedGenerator<AtomicU64, RangeFull>

source

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

source

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

type Output = [TypeValueGenerator<T>; 33]

source

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

source

impl TypeGeneratorWithParams for char

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

source

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

source

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

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

source

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

source

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

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

source

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

source

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
 K: TypeGenerator,
 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, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator, TypeValueGenerator<J>, TypeValueGenerator<K>)

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 18]

source

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

source

impl TypeGeneratorWithParams for AtomicIsize

type Output = BoundedGenerator<AtomicIsize, RangeFull>

source

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

source

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

type Output = [TypeValueGenerator<T>; 19]

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 9]

source

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

source

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

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

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for bool

type Output = BooleanGenerator

source

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

source

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

type Output = [TypeValueGenerator<T>; 27]

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for NonZeroU8

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

source

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

source

impl TypeGeneratorWithParams for AtomicI64

type Output = BoundedGenerator<AtomicI64, RangeFull>

source

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

source

impl TypeGeneratorWithParams for String

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

source

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

source

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

type Output = (TypeValueGenerator<A>,)

source

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

source

impl TypeGeneratorWithParams for i128

type Output = BoundedGenerator<i128, RangeFull>

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 21]

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 10]

source

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

source

impl TypeGeneratorWithParams for AtomicU16

type Output = BoundedGenerator<AtomicU16, RangeFull>

source

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

source

impl TypeGeneratorWithParams for usize

type Output = BoundedGenerator<usize, RangeFull>

source

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

source

impl TypeGeneratorWithParams for NonZeroUsize

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 22]

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 32]

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 25]

source

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

source

impl TypeGeneratorWithParams for i32

type Output = BoundedGenerator<i32, RangeFull>

source

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

source

impl TypeGeneratorWithParams for NonZeroU16

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

source

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

source

impl TypeGeneratorWithParams for u32

type Output = BoundedGenerator<u32, RangeFull>

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 24]

source

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

source

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

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

source

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

source

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

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

source

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

source

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
 L: TypeGenerator,
 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, TypeValueGenerator<C>, TypeValueGenerator<D>, TypeValueGenerator<E>, TypeValueGenerator<F>, TypeValueGenerator<G>, TypeValueGenerator<H>, TypeValueGenerator, TypeValueGenerator<J>, TypeValueGenerator<K>, TypeValueGenerator<L>)

source

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

source

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

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

source

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

source

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

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

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for AtomicU32

type Output = BoundedGenerator<AtomicU32, RangeFull>

source

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

source

impl TypeGeneratorWithParams for u64

type Output = BoundedGenerator<u64, RangeFull>

source

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

source

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

type Output = [TypeValueGenerator<T>; 23]

source

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

source

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

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

source

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

source

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

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

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 16]

source

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

source

impl TypeGeneratorWithParams for i64

type Output = BoundedGenerator<i64, RangeFull>

source

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

source

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

type Output = [TypeValueGenerator<T>; 1]

source

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

source

impl TypeGeneratorWithParams for AtomicU8

type Output = BoundedGenerator<AtomicU8, RangeFull>

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for NonZeroI32

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

source

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

source

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

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

source

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

source

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

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

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for Duration

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 15]

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for ()

type Output = ()

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 14]

source

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

source

impl TypeGeneratorWithParams for AtomicI16

type Output = BoundedGenerator<AtomicI16, RangeFull>

source

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

source

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

type Output = [TypeValueGenerator<T>; 26]

source

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

source

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

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

source

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

source

impl TypeGeneratorWithParams for NonZeroU32

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

source

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

source

impl<T> TypeGeneratorWithParams for [T; 0]

type Output = [T; 0]

source

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

source

impl TypeGeneratorWithParams for u16

type Output = BoundedGenerator<u16, RangeFull>

source

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

source

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

type Output = [TypeValueGenerator<T>; 29]

source

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

source

impl TypeGeneratorWithParams for f32

type Output = BoundedGenerator<f32, RangeFull>

source

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

source

impl TypeGeneratorWithParams for u128

type Output = BoundedGenerator<u128, RangeFull>

source

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

source

impl TypeGeneratorWithParams for i8

type Output = BoundedGenerator<i8, RangeFull>

source

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

source

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

type Output = [TypeValueGenerator<T>; 20]

source

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

source

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

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

source

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

source

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

type Output = [TypeValueGenerator<T>; 6]

source

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

source

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

type Output = [TypeValueGenerator<T>; 30]

source

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

source

Trait bolero::generator::TypeGeneratorWithParams

Required Associated Types

type Output: ValueGenerator

Required Methods

fn gen_with() -> Self::Output

Implementations on Foreign Types

impl TypeGeneratorWithParams for NonZeroI128

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

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

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

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

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

impl TypeGeneratorWithParams for NonZeroI16

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

fn gen_with() -> <NonZeroI16 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

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

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

type Output = BoundedGenerator<i16, RangeFull>

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

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 TypeGeneratorWithParams for AtomicUsize

type Output = BoundedGenerator<AtomicUsize, RangeFull>

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

impl TypeGeneratorWithParams for NonZeroU128

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

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

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

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

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

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

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

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

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

impl TypeGeneratorWithParams for f64

type Output = BoundedGenerator<f64, RangeFull>

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

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

type Output = BoundedGenerator<u8, RangeFull>

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

impl TypeGeneratorWithParams for isize

type Output = BoundedGenerator<isize, RangeFull>

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

impl TypeGeneratorWithParams for AtomicI32

type Output = BoundedGenerator<AtomicI32, RangeFull>

fn gen_with() -> <AtomicI32 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

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<T> TypeGeneratorWithParams for [T; 5] where T: TypeGenerator,

type Output = [TypeValueGenerator<T>; 5]

fn gen_with() -> <[T; 5] 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<T> TypeGeneratorWithParams for [T; 12] where T: TypeGenerator,

type Output = [TypeValueGenerator<T>; 12]

fn gen_with() -> <[T; 12] 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<T> TypeGeneratorWithParams for [T; 17] where T: TypeGenerator,

type Output = [TypeValueGenerator<T>; 17]

fn gen_with() -> <[T; 17] 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 I: TypeGenerator, 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>, TypeValueGenerator<I>)

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

impl TypeGeneratorWithParams for NonZeroU64

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

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

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

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

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

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

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

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

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

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

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

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<T> TypeGeneratorWithParams for [T; 5] where
T: TypeGenerator,

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

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

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

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

impl<I, A, B, C, D, E, F, G, H> TypeGeneratorWithParams 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 gen_with(
) -> <(A, B, C, D, E, F, G, H, I) as TypeGeneratorWithParams>::Output

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

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

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

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

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

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<T> TypeGeneratorWithParams for [T; 18] where
T: TypeGenerator,

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

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<T> TypeGeneratorWithParams for [T; 9] where
T: TypeGenerator,

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

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 [T; 27] where
T: TypeGenerator,