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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

impl<T> TypeGeneratorWithParams for [T; 0]

type Output = [T; 0]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 1]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 2]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 3]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 4]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 5]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 6]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 7]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 8]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 9]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 10]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 11]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 12]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 13]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 14]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 15]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 16]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 17]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 18]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 19]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 20]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 21]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 22]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 23]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 24]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 25]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 26]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 27]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 28]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 29]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 30]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 31]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 32]

fn gen_with() -> Self::Output

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

type Output = [TypeValueGenerator<T>; 33]

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicI8

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicU8

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicI16

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicU16

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicI32

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicU32

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicI64

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicU64

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicIsize

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicUsize

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for bool

type Output = BooleanGenerator

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for char

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u8

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i8

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u16

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i16

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u32

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i32

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u64

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i64

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u128

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i128

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for usize

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for isize

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI8

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU8

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI16

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU16

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI32

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU32

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI64

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU64

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI128

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU128

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroIsize

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroUsize

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for Duration

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for ()

type Output = ()

fn gen_with() -> Self::Output

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

type Output = (TypeValueGenerator<A>,)

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

impl<Q: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator> TypeGeneratorWithParams for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)

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() -> Self::Output

impl<R: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator> TypeGeneratorWithParams for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)

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() -> Self::Output

impl<S: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator> TypeGeneratorWithParams for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)

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() -> Self::Output

impl<T: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator> TypeGeneratorWithParams for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T)

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() -> Self::Output

impl<U: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator> TypeGeneratorWithParams for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U)

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() -> Self::Output

impl<V: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator> TypeGeneratorWithParams for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V)

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

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

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() -> Self::Output

impl<AB: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator> 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)

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() -> Self::Output

impl<AC: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator> 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)

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() -> Self::Output

impl<AD: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator, AC: TypeGenerator> 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)

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() -> Self::Output

impl<AE: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator, AC: TypeGenerator, AD: TypeGenerator> 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)

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() -> Self::Output

impl<AF: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator, AC: TypeGenerator, AD: TypeGenerator, AE: TypeGenerator> 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)

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() -> Self::Output

impl<AG: TypeGenerator, A: TypeGenerator, B: TypeGenerator, C: TypeGenerator, D: TypeGenerator, E: TypeGenerator, F: TypeGenerator, G: TypeGenerator, H: TypeGenerator, I: TypeGenerator, J: TypeGenerator, K: TypeGenerator, L: TypeGenerator, M: TypeGenerator, N: TypeGenerator, O: TypeGenerator, P: TypeGenerator, Q: TypeGenerator, R: TypeGenerator, S: TypeGenerator, T: TypeGenerator, U: TypeGenerator, V: TypeGenerator, W: TypeGenerator, X: TypeGenerator, Y: TypeGenerator, Z: TypeGenerator, AA: TypeGenerator, AB: TypeGenerator, AC: TypeGenerator, AD: TypeGenerator, AE: TypeGenerator, AF: TypeGenerator> 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)

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() -> Self::Output

Loading content...

Implementors

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

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

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

fn gen_with() -> Self::Output

Loading content...