Trait bolero_generator::TypeGeneratorWithParams

pub trait TypeGeneratorWithParams {
    type Output: ValueGenerator;

    // Required method
    fn gen_with() -> Self::Output;
}

Convert a type generator into the default value generator

Required Associated Types

type Output: ValueGenerator

Required Methods

fn gen_with() -> Self::Output

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl TypeGeneratorWithParams for bool

type Output = BooleanGenerator

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for char

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for f32

type Output = BoundedGenerator<f32, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for f64

type Output = BoundedGenerator<f64, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i8

type Output = BoundedGenerator<i8, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i16

type Output = BoundedGenerator<i16, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i32

type Output = BoundedGenerator<i32, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i64

type Output = BoundedGenerator<i64, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for i128

type Output = BoundedGenerator<i128, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for isize

type Output = BoundedGenerator<isize, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u8

type Output = BoundedGenerator<u8, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u16

type Output = BoundedGenerator<u16, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u32

type Output = BoundedGenerator<u32, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u64

type Output = BoundedGenerator<u64, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for u128

type Output = BoundedGenerator<u128, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for ()

type Output = ()

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for usize

type Output = BoundedGenerator<usize, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for String

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicI8

type Output = BoundedGenerator<AtomicI8, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicI16

type Output = BoundedGenerator<AtomicI16, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicI32

type Output = BoundedGenerator<AtomicI32, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicI64

type Output = BoundedGenerator<AtomicI64, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicIsize

type Output = BoundedGenerator<AtomicIsize, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicU8

type Output = BoundedGenerator<AtomicU8, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicU16

type Output = BoundedGenerator<AtomicU16, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicU32

type Output = BoundedGenerator<AtomicU32, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicU64

type Output = BoundedGenerator<AtomicU64, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for AtomicUsize

type Output = BoundedGenerator<AtomicUsize, RangeFull>

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for Duration

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI8

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI16

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI32

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI64

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroI128

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroIsize

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU8

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU16

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU32

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU64

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroU128

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

fn gen_with() -> Self::Output

impl TypeGeneratorWithParams for NonZeroUsize

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

fn gen_with() -> Self::Output

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

type Output = (TypeValueGenerator<A>,)

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

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 + Hash + Eq, V: TypeGenerator> TypeGeneratorWithParams for HashMap<K, V>

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

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<Left: TypeGenerator, Right: TypeGenerator> TypeGeneratorWithParams for Either<Left, Right>

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

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<Ok: TypeGenerator, Err: TypeGenerator> TypeGeneratorWithParams for Result<Ok, Err>

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

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> 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<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<T: TypeGenerator, const LEN: usize> TypeGeneratorWithParams for [T; LEN]

type Output = [TypeValueGenerator<T>; LEN]

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 + Hash + Eq> TypeGeneratorWithParams for HashSet<V>

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

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

Implementors

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

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

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

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

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

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

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

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

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

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

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

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