[−][src]Trait bolero_generator::ValueGenerator
Generate a value with a parameterized generator
Associated Types
type Output
Required methods
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
Generates a value with the given driver
Provided methods
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
Mutates an existing value with the given driver
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>
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>
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>
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>
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>
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>
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.
Implementations on Foreign Types
impl ValueGenerator for String
[src]
impl<V: ValueGenerator> ValueGenerator for HashSet<V> where
V::Output: Sized + Hash + Eq,
[src]
V::Output: Sized + Hash + Eq,
type Output = HashSet<V::Output>
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<V: ValueGenerator, K: ValueGenerator> ValueGenerator for HashMap<K, V> where
K::Output: Sized + Hash + Eq,
[src]
K::Output: Sized + Hash + Eq,
type Output = HashMap<K::Output, V::Output>
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
impl<T> ValueGenerator for [T; 0]
[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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
impl ValueGenerator for bool
[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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl ValueGenerator for char
[src]
impl ValueGenerator for u8
[src]
impl ValueGenerator for i8
[src]
impl ValueGenerator for u16
[src]
impl ValueGenerator for i16
[src]
impl ValueGenerator for u32
[src]
impl ValueGenerator for i32
[src]
impl ValueGenerator for u64
[src]
impl ValueGenerator for i64
[src]
impl ValueGenerator for u128
[src]
impl ValueGenerator for i128
[src]
impl ValueGenerator for usize
[src]
impl ValueGenerator for isize
[src]
impl ValueGenerator for f32
[src]
impl ValueGenerator for f64
[src]
impl ValueGenerator for ()
[src]
impl<A: ValueGenerator> ValueGenerator for (A,)
[src]
type Output = (A::Output,)
fn generate<D_: Driver>(&self, driver: &mut D_) -> Option<Self::Output>
[src]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D_: Driver>(
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D_,
value: &mut Self::Output
) -> Option<()>
impl<'a, T: ValueGenerator> ValueGenerator for &'a T
[src]
type Output = T::Output
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<T> ValueGenerator for PhantomData<T>
[src]
Loading content...
Implementors
impl ValueGenerator for BooleanGenerator
[src]
impl<G: ValueGenerator<Output = char>, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for StringGenerator<G, L>
[src]
type Output = String
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<G: ValueGenerator, F: Fn(&G::Output) -> bool> ValueGenerator for FilterGenerator<G, F>
[src]
impl<G: ValueGenerator, F: Fn(G::Output) -> Option<T>, T> ValueGenerator for FilterMapGenerator<G, F>
[src]
impl<G: ValueGenerator, H: ValueGenerator, F: Fn(G::Output) -> H> ValueGenerator for AndThenGenerator<G, F>
[src]
impl<G: ValueGenerator, M: Fn(G::Output) -> T, T> ValueGenerator for MapGenerator<G, M>
[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]
K::Output: Sized + Ord,
type Output = BTreeMap<K::Output, V::Output>
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 HashMapGenerator<K, V, L> where
K::Output: Sized + Hash + Eq,
[src]
K::Output: Sized + Hash + Eq,
type Output = HashMap<K::Output, V::Output>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<O: OneOfGenerator> ValueGenerator for OneOf<O>
[src]
type Output = O::Output
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<O: OneValueOfGenerator> ValueGenerator for OneValueOf<O>
[src]
type Output = O::Output
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<Seconds, Nanos> ValueGenerator for DurationGenerator<Seconds, Nanos> where
Seconds: ValueGenerator<Output = u64>,
Nanos: ValueGenerator<Output = u32>,
[src]
Seconds: ValueGenerator<Output = u64>,
Nanos: ValueGenerator<Output = u32>,
type Output = Duration
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(&self, driver: &mut D, value: &mut Duration) -> Option<()>
[src]
impl<Start, End, T> ValueGenerator for RangeGenerator<Start, End> where
Start: ValueGenerator<Output = T>,
End: ValueGenerator<Output = T>,
[src]
Start: ValueGenerator<Output = T>,
End: ValueGenerator<Output = T>,
impl<Start, End, T> ValueGenerator for RangeInclusiveGenerator<Start, End> where
Start: ValueGenerator<Output = T>,
End: ValueGenerator<Output = T>,
[src]
Start: ValueGenerator<Output = T>,
End: ValueGenerator<Output = T>,
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<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<T: TypeGenerator> ValueGenerator for TypeValueGenerator<T>
[src]
type Output = T
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(&self, driver: &mut D, value: &mut T) -> Option<()>
[src]
impl<T: Clone> ValueGenerator for Constant<T>
[src]
impl<V: ValueGenerator> ValueGenerator for BTreeSet<V> where
V::Output: Sized + Ord,
[src]
V::Output: Sized + Ord,
type Output = BTreeSet<V::Output>
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<V: ValueGenerator> ValueGenerator for BinaryHeap<V> where
V::Output: Sized + Ord,
[src]
V::Output: Sized + Ord,
type Output = BinaryHeap<V::Output>
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<V: ValueGenerator, K: ValueGenerator> ValueGenerator for BTreeMap<K, V> where
K::Output: Sized + Ord,
[src]
K::Output: Sized + Ord,
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]
V::Output: Sized + Ord,
type Output = BTreeSet<V::Output>
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for BinaryHeapGenerator<V, L> where
V::Output: Sized + Ord,
[src]
V::Output: Sized + Ord,
type Output = BinaryHeap<V::Output>
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
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]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
impl<V: ValueGenerator, L: ValueGenerator<Output = Len>, Len: Into<usize>> ValueGenerator for HashSetGenerator<V, L> where
V::Output: Sized + Hash + Eq,
[src]
V::Output: Sized + Hash + Eq,
type Output = HashSet<V::Output>
fn generate<D: Driver>(&self, driver: &mut D) -> Option<Self::Output>
[src]
fn mutate<D: Driver>(
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>
[src]
&self,
driver: &mut D,
value: &mut Self::Output
) -> Option<()>