[−][src]Trait bolero_generator::ValueGenerator

pub trait ValueGenerator: Sized {
    type Output;
    fn generate<R: Driver>(&self, driver: &mut R) -> Option<Self::Output>;

    fn map<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F> { ... }
    fn map_gen<F: Fn(Self::Output) -> T, T>(
        self, 
        map: F
    ) -> MapGenerator<Self, F> { ... }
    fn and_then<F: Fn(Self::Output) -> T, T: ValueGenerator>(
        self, 
        and_then: F
    ) -> AndThenGenerator<Self, F> { ... }
    fn and_then_gen<F: Fn(Self::Output) -> T, T: ValueGenerator>(
        self, 
        and_then: F
    ) -> AndThenGenerator<Self, F> { ... }
    fn filter<F: Fn(&Self::Output) -> bool>(
        self, 
        filter: F
    ) -> FilterGenerator<Self, F> { ... }
    fn filter_gen<F: Fn(&Self::Output) -> bool>(
        self, 
        filter: F
    ) -> FilterGenerator<Self, F> { ... }
    fn filter_map<F: Fn(Self::Output) -> Option<T>, T>(
        self, 
        filter_map: F
    ) -> FilterMapGenerator<Self, F> { ... }
    fn filter_map_gen<F: Fn(Self::Output) -> Option<T>, T>(
        self, 
        filter_map: F
    ) -> FilterMapGenerator<Self, F> { ... }
}

Generate a value with a parameterized generator

Associated Types

`type Output`

Loading content...

Required methods

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

Loading content...

Provided methods

`fn map<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F>`

Map the value of a generator

`fn map_gen<F: Fn(Self::Output) -> T, T>(self, map: F) -> MapGenerator<Self, F>`

Map the value of a generator, exists to reduce conflicts with other map functions.

`fn and_then<F: Fn(Self::Output) -> T, T: ValueGenerator>( self, and_then: F ) -> AndThenGenerator<Self, F>`

Map the value of a generator with a new generator

`fn and_then_gen<F: Fn(Self::Output) -> T, T: ValueGenerator>( self, and_then: F ) -> AndThenGenerator<Self, F>`

Map the value of a generator with a new generator, exists to reduce conflicts with other map functions.

`fn filter<F: Fn(&Self::Output) -> bool>( self, filter: F ) -> FilterGenerator<Self, F>`

Filter the value of a generator

`fn filter_gen<F: Fn(&Self::Output) -> bool>( self, filter: F ) -> FilterGenerator<Self, F>`

Filter the value of a generator, exists to reduce conflicts with other filter functions.

`fn filter_map<F: Fn(Self::Output) -> Option<T>, T>( self, filter_map: F ) -> FilterMapGenerator<Self, F>`

Filter the value of a generator and map it to something else

`fn filter_map_gen<F: Fn(Self::Output) -> Option<T>, T>( self, filter_map: F ) -> FilterMapGenerator<Self, F>`

Filter the value of a generator and map it to something else, exists to reduce conflicts with other filter_map functions.

Loading content...

Implementations on Foreign Types

`impl ValueGenerator for String`[src]

`type Output = Self`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl<T> ValueGenerator for [T; 0]`[src]

`type Output = [T; 0]`

`fn generate<D_: Driver>(&self, _driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 1]`[src]

`type Output = [G::Output; 1]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 2]`[src]

`type Output = [G::Output; 2]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 3]`[src]

`type Output = [G::Output; 3]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 4]`[src]

`type Output = [G::Output; 4]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 5]`[src]

`type Output = [G::Output; 5]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 6]`[src]

`type Output = [G::Output; 6]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 7]`[src]

`type Output = [G::Output; 7]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 8]`[src]

`type Output = [G::Output; 8]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 9]`[src]

`type Output = [G::Output; 9]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 10]`[src]

`type Output = [G::Output; 10]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 11]`[src]

`type Output = [G::Output; 11]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 12]`[src]

`type Output = [G::Output; 12]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 13]`[src]

`type Output = [G::Output; 13]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 14]`[src]

`type Output = [G::Output; 14]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 15]`[src]

`type Output = [G::Output; 15]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 16]`[src]

`type Output = [G::Output; 16]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 17]`[src]

`type Output = [G::Output; 17]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 18]`[src]

`type Output = [G::Output; 18]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 19]`[src]

`type Output = [G::Output; 19]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 20]`[src]

`type Output = [G::Output; 20]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 21]`[src]

`type Output = [G::Output; 21]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 22]`[src]

`type Output = [G::Output; 22]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 23]`[src]

`type Output = [G::Output; 23]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 24]`[src]

`type Output = [G::Output; 24]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 25]`[src]

`type Output = [G::Output; 25]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 26]`[src]

`type Output = [G::Output; 26]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 27]`[src]

`type Output = [G::Output; 27]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 28]`[src]

`type Output = [G::Output; 28]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 29]`[src]

`type Output = [G::Output; 29]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 30]`[src]

`type Output = [G::Output; 30]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 31]`[src]

`type Output = [G::Output; 31]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 32]`[src]

`type Output = [G::Output; 32]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator> ValueGenerator for [G; 33]`[src]

`type Output = [G::Output; 33]`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl ValueGenerator for bool`[src]

`type Output = bool`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self::Output>`[src]

`impl<T: TypeGenerator + BoundedValue<Self>> ValueGenerator for Range<T>`[src]

`type Output = T`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<T: TypeGenerator + BoundedValue<Self>> ValueGenerator for RangeFrom<T>`[src]

`type Output = T`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<T: TypeGenerator + BoundedValue<Self>> ValueGenerator for RangeInclusive<T>`[src]

`type Output = T`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<T: TypeGenerator + BoundedValue<Self>> ValueGenerator for RangeTo<T>`[src]

`type Output = T`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<T: TypeGenerator + BoundedValue<Self>> ValueGenerator for RangeToInclusive<T>`[src]

`type Output = T`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl ValueGenerator for char`[src]

`type Output = char`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for u8`[src]

`type Output = u8`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for i8`[src]

`type Output = i8`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for u16`[src]

`type Output = u16`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for i16`[src]

`type Output = i16`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for u32`[src]

`type Output = u32`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for i32`[src]

`type Output = i32`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for u64`[src]

`type Output = u64`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for i64`[src]

`type Output = i64`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for u128`[src]

`type Output = u128`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for i128`[src]

`type Output = i128`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for usize`[src]

`type Output = Self`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for isize`[src]

`type Output = isize`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for f32`[src]

`type Output = f32`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for f64`[src]

`type Output = f64`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl ValueGenerator for ()`[src]

`type Output = ()`

`fn generate<D: Driver>(&self, _driver: &mut D) -> Option<Self>`[src]

`impl<A: ValueGenerator> ValueGenerator for (A,)`[src]

`type Output = (A::Output,)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<B: ValueGenerator, A: ValueGenerator> ValueGenerator for (A, B)`[src]

`type Output = (A::Output, B::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<C: ValueGenerator, A: ValueGenerator, B: ValueGenerator> ValueGenerator for (A, B, C)`[src]

`type Output = (A::Output, B::Output, C::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<D: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator> ValueGenerator for (A, B, C, D)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<E: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator> ValueGenerator for (A, B, C, D, E)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<F: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator> ValueGenerator for (A, B, C, D, E, F)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<H: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<I: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<J: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<K: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<L: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<M: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M)`[src]

`type Output = (A::Output, B::Output, C::Output, D::Output, E::Output, F::Output, G::Output, H::Output, I::Output, J::Output, K::Output, L::Output, M::Output)`

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<N: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N)`[src]

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<O: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O)`[src]

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<P: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P)`[src]

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<Q: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q)`[src]

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<R: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R)`[src]

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<S: ValueGenerator, A: ValueGenerator, B: ValueGenerator, C: ValueGenerator, D: ValueGenerator, E: ValueGenerator, F: ValueGenerator, G: ValueGenerator, H: ValueGenerator, I: ValueGenerator, J: ValueGenerator, K: ValueGenerator, L: ValueGenerator, M: ValueGenerator, N: ValueGenerator, O: ValueGenerator, P: ValueGenerator, Q: ValueGenerator, R: ValueGenerator> ValueGenerator for (A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S)`[src]

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

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

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

`fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>`[src]

`impl<T> ValueGenerator for PhantomData<T>`[src]

`type Output = Self`

`fn generate<R: Driver>(&self, _driver: &mut R) -> Option<Self::Output>`[src]

Loading content...

Implementors

`impl ValueGenerator for BooleanGenerator`[src]

`type Output = bool`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator, F: Fn(&G::Output) -> bool> ValueGenerator for FilterGenerator<G, F>`[src]

`type Output = G::Output`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator, F: Fn(G::Output) -> Option<T>, T> ValueGenerator for FilterMapGenerator<G, F>`[src]

`type Output = T`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator, H: ValueGenerator, F: Fn(G::Output) -> H> ValueGenerator for AndThenGenerator<G, F>`[src]

`type Output = H::Output`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<G: ValueGenerator, M: Fn(G::Output) -> T, T> ValueGenerator for MapGenerator<G, M>`[src]

`type Output = T`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<K: ValueGenerator, V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BTreeMapGenerator<K, V, L> where K::Output: Sized + Ord,` [src]

`type Output = BTreeMap<K::Output, V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for StringGenerator<L>`[src]

`type Output = String`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<Left: ValueGenerator, Right: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for EitherGenerator<Left, Right, Selector>`[src]

`type Output = Either<Left::Output, Right::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<O: OneOfGenerator> ValueGenerator for OneOf<O>`[src]

`type Output = O::Output`

`fn generate<R: Driver>(&self, driver: &mut R) -> Option<Self::Output>`[src]

`impl<O: OneValueOfGenerator> ValueGenerator for OneValueOf<O>`[src]

`type Output = O::Output`

`fn generate<R: Driver>(&self, driver: &mut R) -> Option<Self::Output>`[src]

`impl<Ok: ValueGenerator, Err: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for ResultGenerator<Ok, Err, Selector>`[src]

`type Output = Result<Ok::Output, Err::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<Seconds, Nanos> ValueGenerator for DurationGenerator<Seconds, Nanos> where Seconds: ValueGenerator<Output = u64>, Nanos: ValueGenerator<Output = u32>,` [src]

`type Output = Duration`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<Start, End, T> ValueGenerator for RangeGenerator<Start, End> where Start: ValueGenerator<Output = T>, End: ValueGenerator<Output = T>,` [src]

`type Output = Range<T>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<Start, End, T> ValueGenerator for RangeInclusiveGenerator<Start, End> where Start: ValueGenerator<Output = T>, End: ValueGenerator<Output = T>,` [src]

`type Output = RangeInclusive<T>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<T: BoundedValue<B>, G: ValueGenerator<Output = T>, B: RangeBounds<T::BoundValue>> ValueGenerator for BoundedGenerator<G, B>`[src]

`type Output = T`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<T>`[src]

`impl<T: TypeGenerator> ValueGenerator for TypeValueGenerator<T>`[src]

`type Output = T`

`fn generate<R: Driver>(&self, driver: &mut R) -> Option<Self::Output>`[src]

`impl<T: Clone> ValueGenerator for Constant<T>`[src]

`type Output = T`

`fn generate<R: Driver>(&self, _driver: &mut R) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator> ValueGenerator for BTreeSet<V> where V::Output: Sized + Ord,` [src]

`type Output = BTreeSet<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator> ValueGenerator for BinaryHeap<V> where V::Output: Sized + Ord,` [src]

`type Output = BinaryHeap<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator> ValueGenerator for LinkedList<V>`[src]

`type Output = LinkedList<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator> ValueGenerator for Vec<V>`[src]

`type Output = Vec<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator> ValueGenerator for VecDeque<V>`[src]

`type Output = VecDeque<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator, K: ValueGenerator> ValueGenerator for BTreeMap<K, V> where K::Output: Sized + Ord,` [src]

`type Output = BTreeMap<K::Output, V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BTreeSetGenerator<V, L> where V::Output: Sized + Ord,` [src]

`type Output = BTreeSet<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BinaryHeapGenerator<V, L> where V::Output: Sized + Ord,` [src]

`type Output = BinaryHeap<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for LinkedListGenerator<V, L>`[src]

`type Output = LinkedList<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for VecDequeGenerator<V, L>`[src]

`type Output = VecDeque<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for VecGenerator<V, L>`[src]

`type Output = Vec<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

`impl<V: ValueGenerator, Selector: ValueGenerator<Output = bool>> ValueGenerator for OptionGenerator<V, Selector>`[src]

`type Output = Option<V::Output>`

`fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>`[src]

Loading content...